Generalized Reversible Computing
Landauer’s Principle that the loss of information from a computation corresponds to an increase in entropy can be expressed as a rigorous theorem of mathematical physics. However, carefully examining its detailed formulation reveals that the traditional definition identifying logically reversible computational operations with bijective transformations of the full digital state space is actually not the most general characterization, at the logical level, of the complete set of classical computational operations that can be carried out physically with asymptotically zero energy dissipation. To derive the correct set of necessary logical conditions for physical reversibility, we must take into account the effect of initial-state probabilities when applying the detailed form of the Principle. The minimal logical-level requirement for the physical reversibility of deterministic computational operations turns out to be that only the subset of initial states that are assigned nonzero probability in a given statistical operating context must be transformed one-to-one into final states. Consequently, any computational operation can be seen as conditionally reversible, relative to any sufficiently-restrictive precondition on its initial state, and the minimum average dissipation required for any deterministic operation by Landauer’s Principle asymptotically approaches zero in contexts where the probability of meeting any preselected one of its suitable preconditions approaches unity. The concept of conditional reversibility facilitates much simpler designs for asymptotically thermodynamically reversible computational devices and circuits, compared to designs that are restricted to using only fully-bijective operations such as Fredkin/Toffoli type operations. Thus, this more general framework for reversible computing provides a more effective theoretical foundation to use for the design of practical reversible computing hardware than does the more restrictive traditional model of reversible logic. In this paper, we formally develop the theoretical foundations of the generalized model, and briefly survey some of its applications.
Keywords:Landauer’s Principle, foundations of reversible computing, logical reversibility, reversible logic models, reversible hardware design, conditional reversibility, generalized reversible computing
Michael P. Frank
As the end of the semiconductor roadmap approaches, there is today a
growing realization among industry leaders, researchers, funding
agencies and investors that a transition to novel computing paradigms
will be required in order for engineers to continue improving the
energy efficiency (and thus, cost efficiency) of computing technology
beyond the expected final CMOS node, when minimal transistor gate
energies are expected to plateau at around the 40-80
However, the definition of logical reversibility that has been
in widespread use ever since Landauer’s original paper is not, in
fact, the most general definition of logical reversibility that is
consistent with the understanding that a logically reversible
computational process can, in principle, be carried out via an
(asymptotically) thermodynamically reversible physical process. Thus,
the traditional definition of logical reversibility in fact
obscures most of the space of technological possibilities, and
has resulted in a substantial amount of debate and confusion
(e.g., ) regarding the issue of whether logical reversibility is really required for physical
The structure of the rest of this paper is as follows. In Section 2, we review some physical foundations, and then present a simple, general formulation of Landauer’s Principle which follows from basic facts of mathematical physics and information theory. This formulation both illustrates why Landauer’s Principle itself is rigorously true (not debatable), and serves as a starting point for later analysis. Then in Section 3, we reformulate the foundations of reversible computing theory in a way that develops a new theoretical framework that we call Generalized Reversible Computing (GRC), which includes the essential but usually-overlooked concept of conditional reversibility , which generalizes and subsumes the old definition of (unconditionally) logically reversible operations in a way that, critically, accounts for the statistical characteristics that apply in the context of specific computations. In Section 4, we present several examples of conditionally-reversible operations that are useful as building blocks for reversible hardware design, and that are also straightforwardly physically implementable. Many of these operations have already been implicitly utilized by the designers of various reversible hardware concepts (e.g., [4, 5, 6, 7]), despite the fact that most of the existing reversible computing theory literature is completely silent about them, as well as about all other operations in the largest, most diverse class of reversible operations, those that are not also unconditionally reversible. Section 5 briefly discusses why it is GRC, and not the traditional unconditionally-reversible model of reversible computing, that is the appropriate model for understanding asymptotically thermodynamically reversible hardware such as adiabatic switching circuits. Section 6 contrasts GRC’s concept of conditional reversibility with existing concepts of conditions for correctness of reversible computations that have been explored in the literature. Section 7 concludes, and outlines some directions for future work.
A shortened version of this paper titled “Foundations of Generalized Reversible Computing,” which omitted the proofs, was presented at the Conference on Reversible Computation (RC17) in Kolkata, India . A preprint of that shorter version which included the proofs in an appendix was subsequently posted online at . The present version includes the proofs inline, as well as additional figures and discussion. (The intent is to further expand it in preparation for journal submission. )
2 Formulating Landauer’s Principle
Landauer’s Principle is, in essence, simply the observation that the loss of information from a computation corresponds to an increase in physical entropy, which implies a certain associated amount of energy being dissipated to the environment in the form of heat. At one level, this statement is just a tautological consequence of the understanding that the very meaning of physical entropy is, in effect, that part of the total information embodied within a given physical system that has already been permanently lost, in the sense of its having been “scrambled up” (i.e., randomized), through uncertain or chaotic interactions with an unknown environment, to the extent that the system cannot, in isolation, be effectively restored to its original state via any physical procedure that is practically accessible to us. At this level, there is not much more to understand—lost information is entropy, and energy is required to expunge that entropy to the environment (as heat). However, for our purposes, it is helpful to also articulate the meaning of (and justification for) Landauer’s Principle in a more thorough and mathematically rigorous way. This is necessary to (for example) understand exactly what information loss really means, and under what conditions, precisely, information is (or is not) lost in the course of carrying out a given computation. As we will see, such an understanding leads to the realization that there is, in fact, a much wider variety of computational operations that can avoid information loss and entropy emission (and thus are reversible, in those senses) than the traditional theory of reversible computing acknowledges.
To explain all of this more formally, we start with some basic definitions. We will not here require or provide a full explication of quantum theory, but rather, we will work with a simplified set of definitions that is adequate for our purposes. However, our definitions will nevertheless be fully compatible with a more complete quantum-mechanical treatment.
2.1 Physical state spaces, bijective dynamics.
We first present a basic concept of a space (set) of physical states, and explain what we mean when we say that a physical dynamics on a given state space is bijective. The bijectivity of real physical dynamics is the fundamental postulate from which Landauer’s Principle derives.
State spaces. For our purposes, a (physical) state space is a set of entities called (physical) states that are mutually distinct objects from each other (mathematically), and that are also reliably distinguishable from each other, physically.
It is important, for our purposes, that states be reliably physically distinguishable from each other, as well as being mathematically distinct, since otherwise the mathematical distinction between them could not reliably convey any information-theoretic content. An example of two states that are physically distinguishable from each other would be any two pure quantum states represented by mutually orthogonal (perpendicular) quantum state vectors. In contrast, an example of a pair of states that would be mathematically distinct, but not reliably physically distinguishable, would be any pair of quantum state vectors spanned by any angle .
An acceptable example of a state space, for purposes of our definition, would therefore be any orthonormal set of basis vectors for any -dimensional Hilbert space.
For simplicity, here we assume that the cardinality of the state space is a finite, natural number. Countably infinite or transfinite (e.g., continuous) state spaces are not explicitly considered in this paper; however, this is not a significant limitation, since it is believed  that the accessible universe has only finitely many distinguishable states anyway, and, even if that turns out to be incorrect, certainly any practically-buildable technology will only be able to access finite-sized physical systems exhibiting only finitely many distinguishable states for the foreseeable future (barring major upheavals in fundamental physics).
Next, we need a concept of a bijective (reversible and deterministic) dynamics:
Bijective dynamics. Given any state space of possible states of a system at some reference time point , a deterministic, reversible dynamics or simply bijective dynamics on is a parameterized family of total, one-to-one, single-valued functions , where the parameter , mapping states in onto states in the parameterized family of state spaces , and where always has the same cardinality as (that is, for all ). Additionally, we require that , and that must be the identity function on .
In this definition, the real-valued parameter represents elapsed time from the reference time point , and is the function mapping states that are in at the initial time point to the new states in that they will become after the time has elapsed. See Figure 1. The set is simply the space of possible states at time , given that the state at time is in . Note that will not, in general, be the same state space as for elapsed times , since states may, in general, transform continuously over time, yet, the initial state space under consideration was assumed to only be countable, so it does not itself include sufficiently many states to allow continuous change while still remaining within the same state set.
The assumption that is a single-valued function for positive values of implies that the dynamics is deterministic (meaning, the state at any future time is determined by the present state at ), and the assumption that is single-valued for negative values of implies that it is “reverse-deterministic” or reversible, meaning, the state at any past time can be determined from the present state.
Also, although here we did not specifically require to exhibit general time-translation symmetry (that is, to always have exactly the same form, regardless of the initial time ), the fact that, for any , the function is one-to-one implies that it has a corresponding inverse function , and therefore, also induces a bijective map
between the states at any pair of times and , where . Thus, even if the dynamics was reexpressed relative to any different reference time point , then, even if it didn’t retain exactly the same form under that transformation, it would, at least, remain bijective.
Finally, we need a concept of the completeness of state-space descriptions of physical systems. For our purposes, we will take “physical system” itself to be a primitive, undefined concept.
Completeness of state spaces. We say that a state space representing a set of distinguishable states of a particular physical system at some point in time is complete if and only if there is no larger state space , i.e. with , that also describes .
The point of the concept of the completeness of the state space is just to say that the state representation of the physical state is fully detailed, i.e., that its states are not actually composite entities that could be factored into aggregates of more fundamental distinguishable states. It is perhaps an open philosophical question about physics whether we can ever really know with certainty that a given state-space description of a physical system is really complete; however, we generally assume that there is always some state-space description that is at least complete with respect to all of the ways to probe a system that have been discovered at a given point in time.
Now, given the above definitions, we can state the following assertion, which we consider to be a solidly-established fact about all of the viable modern theories of fundamental physics, and which can be considered to be the basic postulate upon which the proof of Landauer’s Principle rests.
Bijectivity of physical dynamics. All viable modern theories of fundamental physics (i.e., all those that are empirically well-founded, logically consistent, and parsimonious) exhibit the property that for any closed (isolated) physical system , if we characterize it by some complete state space at some reference time , the time-evolution of that system (over all future and past times) is described by some bijective dynamics on .
Assertion 1 definitely holds in the case of all viable quantum theories, which share the property that the system’s dynamics is implicitly determined by some time-independent, rank- Hamiltonian operator (an energy-valued Hermitian linear operator), from which we can derive a unitary time-evolution operator
and the evolved state space at time is then just
where denotes a representation of state as a quantum state vector; e.g., expressed in a basis where the states correspond to basis vectors, this could simply be a rank- column vector, whose element is 1, and other elements 0. The map determined by the dynamics between the state spaces at different times is then just
The above formulation covers standard quantum mechanics, and also (if we extend it to infinite-dimensional state spaces) all of the standard relativistic quantum field theories, which can successfully model all of the known fundamental physical forces except for gravity. Although, at this time, we do not yet have a complete and well-tested theory of physics that succeeds at unifying gravity (i.e., general relativity) with quantum mechanics, it is generally assumed by physicists that whenever we do find such a theory, it will still exhibit the same general properties above that are shared by all of the existing quantum theories.
It’s important to note that if physical dynamics was not reversible, then the Second Law of Thermodynamics would not be true; in detail, if the dynamical map was many-to-one for any positive elapsed times , then formerly-distinguishable states could merge together, and entropy would spontaneously decrease. So, from this perspective, the reversibility of real physical dynamics follows from the empirical observation that the Second Law does not appear to be violated. Likewise, the determinism of the dynamics can be inferred from empirical observations showing e.g. the effectiveness of Schrödinger’s deterministic wave equation at modeling the observed dynamics of closed quantum systems.
In any event, if one accepts the bijectivity of dynamical evolution as a truism of mathematical physics, then the validity of Landauer’s Principle follows rigorously from it, as a theorem. To state and prove that theorem formally, we will require just a few more definitions.
2.2 Computational state spaces.
Here, we define what we mean by a computational, as opposed to physical, state space. Such a distinction is necessary because computational states are typically considered to be abstract, higher-level entities; we do not typically consider that what is important in our description of a computer includes the complete, fully-detailed physical dynamics of the physical system implementing that computer.
Computational subspaces, computational states. Given a state space , a computational subspace of is a partition of the set , i.e., a set of non-overlapping, non-empty subsets of whose union is . (See Figure 2 for an illustration.) We say that a physical system is in computational state whenever the physical state of the system is not reliably distinguishable from some such that .
The idea of a computational subspace is simply that not all features of a system’s physical state are computationally meaningful; for example, the detailed microscopic state of a heat sink surrounding a computer would not generally be considered to be part of the machine’s computational state. Two states that are, in principle, distinguishable from each other physically, but that are not considered to be distinct in terms of their computational interpretation, would be considered to be part of the same computational state .
Note that according to this definition, a system could be considered to be in more than one computational state at the same time, in the case where it takes on a physical state that is not reliably distinguishable from either of two different physical states that happen to be contained in different elements of the partition . This would be the case, for example, in a quantum computer that has been carefully prepared so as to occupy a quantum superposition of two distinct computational states (and such situations are, in fact, required for execution of quantum algorithms). However, for our purposes in the present paper, we will assume that real computational systems are normally intentionally designed to be highly decoherent systems in which the physical states that are used to assemble computational states correspond to naturally-stable “pointer” states, as in . Under this assumption, superpositions of computational states will, in practice, be extremely rare; therefore, we normally assume that a system can be considered to only occupy one computational state at a time, with probability approaching 1. A more comprehensive version of the theoretical model presented in this paper would relax that restriction.
Next, let us assume that we can also identify an appropriate computational subspace which is a partition of the evolved physical state space at any past or future time . If we model the computer itself as being assembled or disassembled over the timeline, the size of the computational subspace might change over time, but that will not materially affect any aspect of our subsequent discussion.
2.3 Probability distributions, entropy measures.
Consider, now, any initial-state probability distribution over the complete state space at time , that is, a real-valued function
such that the state probabilities sum to unity, . This then clearly induces an implied initial probability distribution over the computational states at time as well:
where denotes the th physical state in computational state .
For any probability distributions and over physical and computational states, we can then define corresponding entropy measures:
Physical entropy. Given any probability distribution over a physical state space , the physical entropy is defined by:
where the logarithm there can be considered to be an indefinite logarithm, dimensioned in generic logarithmic units, or, if we wish to express the result in particular logarithmic units such as bits (log base 2 units) or “nats” (log base e units) we can substitute a definite logarithm for the indefinite one as follows:
where note that Boltzmann’s constant here can be
considered to simply represent 1 nat or the natural logarithmic unit
(log e), interpreted as being a physical unit of
The above definition of physical entropy comports with the standard quantum-mechanical concept of the von Neumann entropy of a mixed quantum state ; if one diagonalizes the density-matrix description of any mixed quantum state, the probabilities of the basis states lie along the diagonal, and the standard definition of Von Neumann entropy reduces to the definition above.
The bijectivity of physical dynamics then implies the following theorem:
Conservation of entropy. The physical entropy of any closed system, as determined for any initial state distribution , is exactly conserved over time, under any viable physical dynamics.
In other words, under any of the viable theories of fundamental physics mentioned in Assertion 1, if the physical entropy of an initial-state distribution at time is , and we evolve that system over an elapsed time according to its bijective dynamics , the physical entropy of its final-state probability distribution that applies at time will be the exact same value, .
Since the dynamical map from the state at time to the state at time is a one-to-one function, the probability distributions and comprise the exact same bag (multiset) of real numbers (albeit reassigned to new states); therefore, the entropy values of these distributions are identical. ∎
It’s a standard theorem of quantum theory that the von Neumann entropy of any mixed quantum state is conserved under any unitary time-evolution operator ; Theorem 2.1 can be considered to be a generalization of that standard theorem that does not depend on the full mathematical structure of quantum theory, but only on the bijectivity of its dynamics.
It’s important to note that the validity of Theorem 2.1 (entropy is conserved) depends on the assumption that, from our theoretical perspective, we know (and in principle, can track) the dynamical evolution of the state exactly—if we did not (for example, if we didn’t know the laws of physics exactly, or if we discarded some information about the state as the system evolved), then we would accumulate increased uncertainty about the final state, compared to the initial state, and so entropy would be seen to increase in practice, which is what we in fact observe. But, it remains true that if we knew the precise dynamics, and could track the evolution exactly, the entropy of a given state distribution would not be seen to increase at all as that distribution is evolved by the dynamics.
Next, we can define what is sometimes called the “information entropy” of the computational state:
Information entropy. Given any probability distribution over a computational state space , the information entropy or computational entropy is defined by:
which, like , is dimensioned in arbitrary logarithmic units.
Note that further, this is really the exact same definition as for physical entropy , except that here, we are just applying it to a different probability distribution, namely, the one induced over the computational states. The fact that different logarithmic units are most conventionally chosen for computational versus physical entropy (bits versus nats, respectively) is just an historical accident, an arbitrary difference in units, and is totally inconsequential. Entropy is entropy!
One reason, however, why we might sometimes want to use the name “information entropy” for this concept is that the information contained in the computational state might, in principle, be known information (and thus, not “true” entropy at all!) if the history of how that information was computed from other known information is known. However, from the perspective of an individual computational device that does not have access to that kind of nonlocal knowledge, an uncertain statistical description of the state remains appropriate, and thus, the information in the computational state is effectively still entropy, for purposes of taking a thermodynamics of computation perspective towards the analysis of local device operations.
Finally, we can define the “non-computational entropy” as comprising the remainder of the total physical entropy, other than the computational part:
Non-computational entropy. Given a situation where the total physical entropy is and the computational entropy is , the non-computational entropy is defined by:
It is clear that always, since the summing of probabilities that occurs in aggregating physical states to form computational states can only reduce the entropy; the computational entropy can, thus, never be greater than the total physical entropy.
To understand why non-computational entropy is physically meaningful, it is helpful to consider the following theorem:
Physical role of non-computational entropy. Non-computational entropy is the physical entropy conditioned on the computational information. In other words,
where denotes the conditional entropy of random variable (the physical state) when the value of random variable (the computational state) is known.
Conditional entropy is itself defined, in general, by:
or in other words, as the weighted average, given the probability distribution over possible values of random variable , of the entropies of the probability distribution over , conditioned on the given value of .
Since the physical state determines the computational state , specifying the physical state is the same as jointly specifying and , and so the statement of the theorem boils down to a special case of the chain rule of conditional entropy,
since the conditional entropy is stated by the theorem to equal . ∎
The practical import of this theorem is simply to clarify that the non-computational entropy is not just some arbitrary, meaningless quantity, rather, it is the expected value of the physical entropy in contexts where the computational entropy is really known information, which will commonly be the case, whenever the computational state is computed deterministically from other known information. Therefore, it has a physical significance. Increased non-computational entropy means increased physical entropy from the user’s perspective (assuming that the user cannot keep track of the detailed physical state, but only, at most, the computational state).
2.4 Statements of Landauer’s Principle.
The above definitions then suffice to allow us to formulate and prove Landauer’s Principle, in both its most general quantitative form, as well as in another form more frequently seen in the literature.
Landauer’s Principle (general formulation). If the entropy of the computational state of a system at initial time is , and we allow that system to evolve, according to its physical dynamics, to some other “final” time , at which its computational entropy becomes , where is the induced probability distribution over the computational state set at time , then the non-computational entropy is increased by
Total physical entropy is conserved by Theorem 2.1. The computational part of the total entropy decreases by , by hypothesis. Therefore, the noncomputational part (the remainder) must increase by that amount. ∎
That formulation captures the conceptual core of Landauer’s Principle, and as we can see, its proof is really extremely simple, essentially trivial. It amounts to the simple observation that, since total physical entropy is dynamically conserved, then any decrease in computational entropy must cause a corresponding increase in non-computational entropy.
Furthermore, conventional digital devices are typically designed to locally reduce computational entropy, e.g., by erasing “unknown” old bits obliviously (that is, without utilizing independent knowledge of their previous value) or (in other words) by destructively overwriting them with newly-computed values. As a result, typical device operations necessarily eject entropy into the non-computational form, and so, over time, non-computational entropy typically builds up in the system (manifesting as heating), but, we generally assume that it cannot build up indefinitely in the system (since eventually the physical mechanism would break down from overheating), but must instead eventually be moved out into some external thermal environment at some temperature , which involves the dissipation of energy to the form of heat in that environment, by the very definition of thermodynamic temperature,
where and are respectively the entropy and heat energy content of a heat bath at thermodynamic equilibrium. From Theorem 2.3 together with these facts, along with the logarithmic identity , follows the more commonly-seen statement of Landauer’s Principle:
Landauer’s Principle (common form). For each bit’s worth of information that is lost within a computer (e.g., by obliviously erasing or destructively overwriting it), an amount of energy
must eventually be dissipated to the form of heat added to some environment at temperature .
See preceding discussion.
Next, we will see that, if we examine a little more precisely what are the conditions for “entropy ejection” by device operations, we find that such an event, in the case of logically deterministic computational operations, must occur whenever we operate a mechanism that is designed to transform either of (at least) two initial local computational states that each have nonzero probability into the same final computational state—since doing so will result in a local reduction in the computational entropy. We will develop these ideas further in the next section. But, as we will see, the qualifier “have nonzero probability” in the preceding statement turns out to be essential, and this, in fact, is what makes the difference between the traditional theoretical model of reversible computing, and the more generalized framework developed here.
3 Reformulating Reversible Computing Theory
The conceptual development of Generalized Reversible Computing (GRC) theory rests on a process of very carefully and thoroughly analyzing the implications of Landauer’s Principle (in its general formulation above) for computation.
Carrying out such an analysis allows us, first, to formally verify what we call the Fundamental Theorem of Traditional Reversible Computing Theory (Theorem 3.1 below), which states that deterministic computational operations that are always non-entropy-ejecting, independently of their statistical operating context, must be (unconditionally) logically reversible.
However, we can then go further in our analysis, and also prove a new Fundamental Theorem of Generalized Reversible Computing Theory (Theorem 3.3 below), which demonstrates that additionally, a computation that applies any arbitrary deterministic operation (which is, in general, only what we call conditionally logically reversible) within any specific operating context that satisfies any of the preconditions for the reversibility of that operation is also non-entropy-ejecting, according to Landauer’s Principle. This then establishes that it is actually the more general concept of conditional reversibility, rather than the more restrictive traditional concept of unconditional reversibility, that is the most general concept of logical reversibility that is consistent with the requirement of avoiding ejection of entropy from the computational state under Landauer’s Principle.
The key insight that allows us to advance from the traditional theory to the more general one is simply the realization, discussed in , that a computation per se consists of not just a choice of an abstract computational operation to be carried out, but also a specific statistical operating context in which that operation is to be applied. Without considering the specific statistical context, one cannot calculate the initial and final computational entropies with any degree of accuracy, and therefore, one cannot correctly infer whether any entropy is in fact ejected from the computational state in the course of the computation.
The traditional theory of reversible computing, ever since Landauer’s original paper, has typically neglected to emphasize this fact, leading to what is arguably an overemphasis on the more restrictive model of unconditionally-reversible computing that is invoked throughout the majority of the reversible computing literature. By exploring the more general, conditional model, we can design simpler hardware mechanisms for reversible computing than can be modeled within the traditional framework, as we will show in section 4. Therefore, arguably the general model deserves more intensive attention and study than it has, to date, received.
In the following two subsections, we first formally re-develop the traditional theoretical foundations of reversible computing, and then show how to extend those foundations to support the generalized model.
3.1 Traditional Theory of Unconditional Reversibility
Here, we redevelop the foundations of the traditional theory of unconditionally logically-reversible operations, using a language that we can subsequently build upon to develop the generalized theory. We begin by defining some basic concepts of computational devices and operations, explain what it means for computational operations to be deterministic and reversible, define what we mean by a statistical operating context, and what it means to say that a deterministic computational operation is unconditionally reversible, which is the traditional notion of logical reversibility. We can then show why unconditional logical reversibility is indeed necessary if we wish to always avoid ejecting entropy from the computational to the non-computational state independently of the statistical properties that apply within the context of a specific computation. That much is then sufficient, as a basic foundation for traditional reversible computing theory.
Then, in subsection 3.2, we will go further, and show how to develop the more general, context-dependent theory.
Computational devices and operations.
First, let us clarify what we mean by a computational device.
Devices. For our purposes, a computational device will simply be any physical artifact that is capable of carrying out one or more different computational operations (to be defined).
We generally assume that the scale of any given device is circumscribed, in the sense that it is associated with some physical and computational state information that is localizable; for example, this could include the states of some I/O terminals incident on the device, as well as internal states of the device. Although devices are not, strictly speaking, closed systems (since they will generally exchange energy and information/entropy with their environment), we generally assume, for our purposes, that the information-theoretic thermodynamics of individual device operations can be analyzed more or less in isolation from other external systems; that is the significance of saying that devices are “localizable.”
In line with the definitions of the previous section, devices can be considered to have physical and computational state spaces associated with their (assumed-localizable) state. In general, the identity of these sets could change over time for a given device, but that aspect of the situation will not be particularly important to our present analysis.
Next, we define computational operations, that is, operations that are intended to possibly transform the computational state. These can generally include computational operations that are deterministic, nondeterministic, reversible, or irreversible; we’ll clarify the meanings of these terms momentarily.
Computational operations. Given a device with an associated initial local computational state space at some point in time , a computational operation on D that is applicable at is specified by giving a probabilistic transition rule, i.e., a stochastic mapping from the initial computational state at to the final computational state at some later time (with ) by which the operation will have been completed. Let the computational state space at this later time be . Then, the operation is a map from to probability distributions over ; which is characterizable, in terms of random variables for the initial and final computational states, by a conditional probabilistic transition rule
where and . That is, denotes the conditional probability that the final computational state is , given that the initial computational state is .
Note that, if we specify a computational operation in this way, in terms of transition probabilities between computational states, this does not, by itself, say anything about the initial probability distribution over physical or computational states, except that the initial probability distribution over physical states must be one for which implementing the desired transition rule is possible. Although we will not detail this argument here, as long as there are many physical states per computational state, and the detailed physical state is allowed to equilibrate with the thermal environment in between computational operations to the extent that the distribution over physical states within each computational state approaches an equilibrium distribution, this will generally be a requirement that is possible to satisfy.
Deterministic and reversible operations.
Now, for later reference, let us define the concepts of determinism and (unconditional logical) reversibility of computational operations.
Deterministic and nondeterministic operations. A computational operation will be called deterministic if and only if all of the probability distributions are single-valued. In other words, for each possible value of the initial-state index , there is exactly one corresponding value of the final-state index such that (and thus, for this value of , it must be the case that ), while for all other . If an operation is not deterministic, we call it nondeterministic. As a notational convenience, for a deterministic operation , we can write to denote the such that , that is, treating as a simple transition function rather than a stochastic one.
Note that this is a different sense of the word “nondeterministic” than is commonly used in computational complexity theory, when referring to, for example, nondeterministic Turing machines, which conceptually evaluate all of their possible future computational trajectories in parallel. Here, when we use the word “nondeterministic,” we mean it simply in the physicist’s sense, to refer to “randomizing” or “stochastic” operations.
Reversible and irreversible operations. A computational operation will be called (unconditionally logically) reversible if and only if all of the probability distributions have non-overlapping nonzero ranges. In other words, for each possible value of the final-state index , there is at most one corresponding value of the initial-state index such that , while for all other . If an operation is not reversible, we call it irreversible.
Essentially, the above definition is just a statement that the transition relation
specifying which initial states have nonzero probability of transitioning to which final states is an injective relation. (Note, however, that may not be a functional relation, if the operation is nondeterministic.)
Now, up to this point, the notion of “reversible” that we have invoked here is essentially the same concept of (what we call unconditional) logical reversibility that has been used ever since Landauer. And this is, indeed, the appropriate concept for considering the reversibility of computational operations in the abstract, independently of any particular statistical context in which they may be operating. If we wish for a deterministic computational operation to avoid ejecting entropy into the non-computational state no matter what the initial-state distribution is, then it must be an unconditionally reversible operation. This was already observed by Landauer. Let us now set up some more definitions so that we can prove this formally.
Operating contexts and entropy-ejecting operations.
First, we define what we mean by a statistical operating context:
Operating contexts. For a computational operation with an initial computational state space , a (statistical) operating context for that operation is any probability distribution over the initial computational states; for any , the value of gives the probability that the initial computational state is .
And now, we define the concept of an operation that may eject entropy from the computational state:
Entropy-ejecting operations. A computational operation is called (potentially) entropy-ejecting if and only if there is some operating context such that, when the operation is applied within that context, the increase in the non-computational entropy required by Landauer’s Principle is greater than zero. If an operation is not potentially entropy-ejecting, we call it non-entropy-ejecting.
Fundamental theorem of traditional reversible computing.
Now, we can formally prove Landauer’s original result stating that only operations that are logically reversible (in his sense) can always avoid ejecting entropy from the computational state (independently of the operating context).
(Fundamental Theorem of Traditional Reversible Computing) Non-entropy-ejecting deterministic operations must be reversible. If a deterministic computational operation is non-entropy-ejecting, then it is reversible in the sense defined above (its transition relation is injective).
Suppose that is not reversible. Then by definition it is possible to find a final-state index such that there at least two initial state indices (which we identify as without loss of generality) such that both and . Assuming that the operation is also deterministic, we must have that . Thus, all of the probability mass assigned to and by the initial-state probability distribution will get mapped onto the same final state . Therefore, if we let the operating context assign probability to each of states and , then the initial computational entropy , and the final computational entropy , and thus the entropy ejected is . Thus, the operation is potentially entropy-ejecting. Therefore, by contraposition, if a deterministic computational operation is non-entropy-ejecting, then it must be reversible. ∎
Note that in this proof, we chose an operating context that assigned probability 1/2 to the two initial states that are being merged, to construct an example demonstrating that the hypothesized irreversible operation is entropy-ejecting. Actually, however, any nonzero probabilities for these two states would have sufficed; the contribution to the initial computational entropy from those two states would then be greater than zero, which was all that was needed to show that the operation was entropy-ejecting. But, if only one of the two initial states being merged had been assigned nonzero probability, the proof would not have gone through. This is the key realization that sets us up to develop the more general framework of Generalized Reversible Computing. To formalize that framework, we need some more definitions.
3.2 General Theory of Conditional Reversibility
To develop the generalized theory, we define a notion of a computation, which fixes a specific statistical operating context for a computational operation, and then we examine the detailed requirements for a given computation to be non-entropy-ejecting. This leads to the concept of conditional reversibility, which is the most general concept of logical reversibility, and thus provides the appropriate foundation for the generalized theory.
Computations and entropy-ejecting computations.
First, we define our specific technical notion of a computation, by which we mean a given computational operation performed within a specific operating context.
Computations. For our purposes, a computation performed by a device is defined by specifying both a computational operation to be performed by that device, and a specific operating context under which the operation is to be performed.
Now, for specific computations, which carry an associated statistical operating context, as opposed to computational operations considered in a more generic, context-free way, we obtain a new, context-dependent notion of what it means for such a computation to be entropy-ejecting under Landauer’s Principle, and an associated new context-dependent notion of logical reversibility (namely, conditional reversibility) that corresponds to it.
Entropy-ejecting computations. A computation is called (specifically) entropy-ejecting if and only if, when the operation is applied within the specific operating context , the increase in the non-computational entropy required by Landauer’s Principle is greater than zero. If is not specifically entropy-ejecting, we call it non-entropy-ejecting.
In order to characterize the set of deterministic computations that can be non-entropy-ejecting, we need to consider a certain class of computational operations, which we call the conditionally-reversible operations:
Conditionally-reversible computational operations. A deterministic computational operation is called conditionally reversible if and only if there is a non-empty subset of initial computational states (the assumed set) that ’s transition rule maps onto an equal-sized set of final states. (Each maps, one to one, to a unique where .) We say that is the image of under . We also say that is conditionally reversible under the precondition that the initial state is in , or that is a precondition under which is reversible.
It turns out that all deterministic computational operations are, in fact, conditionally reversible, under some sufficiently-restrictive preconditions.
Conditional reversibility of all deterministic operations. All deterministic computational operations are conditionally reversible.
Given a deterministic computational operation with initial computational state space , (which must be non-empty, since it is a partition of a non-empty set of physical states), consider any initial computational state , and let , the singleton set of state . Since the operation is deterministic, for a single final-state index , so then let . Both and are the same size (both singletons), and thus is conditionally reversible under the precondition that the initial state is in . ∎
Note that, although that proof of Theorem 3.2 invoked singleton sets for simplicity, any deterministic operation that has a larger number of different final computational states that are reachable (that is, that have initial states that transition to them) is reversible under at least one precondition set that is of size . To build such an , it suffices, for each reachable final state, to include in any single one of the initial states that transitions to it. Therefore, all deterministic operations that have more than one reachable final computational state are conditionally reversible in this nontrivial sense, and not just in the more trivial sense that we invoked in the proof of Theorem 3.2.
Conditioned reversible operations.
Whenever we wish to fix a specific assumed precondition for the reversibility of a conditionally-reversible operation , we use the following concept:
Conditioned reversible computational operations. Let be any conditionally-reversible computational operation, and let be any of the preconditions under which is reversible. Then the conditioned reversible operation denotes the concept of performing operation in the context of a requirement that precondition is satisfied. Furthermore, for any given computation , we can say that it satisfies the assumed condition for reversibility of with probability if
Fundamental theorem of generalized reversible computing.
The central result of generalized reversible computing theory (Theorem 3.3, below) is then that any deterministic computation will be non-entropy-ejecting (as a computation), and therefore, will avoid any requirement under Landauer’s Principle to dissipate any amount of energy greater than zero to its thermal environment, as long as its operating context assigns probability 1 to any precondition under which its computational operation is reversible.
Moreover (as we see in Theorem 3.4 later), even if the probability of satisfying some such precondition only approaches 1, this is sufficient for the entropy ejected (and energy required to be dissipated) to approach 0.
(Fundamental Theorem of Generalized Reversible Computing) Any deterministic computation is non-entropy-ejecting if and only if at least one of its preconditions for reversibility is satisfied. I.e., let be any deterministic computation (i.e., any computation whose operation is deterministic). Then, part (a): If there is some precondition under which is reversible, such that is satisfied with certainty in the operating context , or in other words, such that
then is a non-entropy-ejecting computation. And, part (b): Alternatively, if no such precondition is satisfied with certainty, then is entropy-ejecting.
Part (a): All of the probability mass in the initial-state distribution falls into initial computational states within the set , which (since is a precondition for the reversibility of ) are mapped, one-to-one, onto an equal number of final computational states by the transition rule . Therefore, the final-state distribution consists of the same bag of probability values as the initial-state distribution, and therefore its computational entropy is the same, . Thus, , and so is non-entropy-ejecting. Part (b): In contrast, if none of ’s preconditions for reversibility is satisfied, then this implies that the set of initial states with nonzero probability is mapped by to a smaller set of final states (since otherwise would itself be a precondition for reversibility that is satisfied), and therefore, by the pigeonhole principle, at least two initial states in must be mapped (and their probability mass carried) to the same final state , and since both and have nonzero probability, and the function that we sum over to compute is subadditive, ’s contribution to the total final computational entropy is less than the total that and contributed to before they were merged; and therefore, the final computational entropy must be less than the initial computational entropy , and thus, the entropy ejected . ∎
The upshot of Theorem 3.3 is that, in order for it to be possible for some device to carry out a given computation in an asymptotically thermodynamically reversible way (with entropy generated approaching zero, and energy dissipated to the environment approaching zero), it is not necessary for the computational operation being performed to be one that is unconditionally logically reversible; rather, it is only necessary (if the operation is deterministic) that there be some precondition for the reversibility of the operation that is satisfied with probability 1, or approaching 1, in the specific operating context in which that device will be performing that operation. For this to work in general (with dissipation approaching 0), the device must be designed with implicit knowledge of not only what conditionally-reversible operation it should perform, but also which specific one of the preconditions for that operation’s reversibility should be assumed to be satisfied.
The following theorem shows why it’s sufficient, for asymptotic thermodynamic reversibility, for the probability of satisfying a given precondition to only approach 1.
Entropy ejection vanishes as precondition certainty approaches unity. Let be any deterministic operation, and let be any precondition under which is reversible, and let be any sequence of operation contexts for within which the total probability mass assigned to approaches 1. Then, in the corresponding sequence of computations, the entropy ejected also approaches 0.
Consider, without loss of generality, any pair of initial states that are both mapped by the operation to the same final state , where , while ; and letting and ; and let be the ratio between the probabilities of these two initial states. Let be the contribution of this state merger to the total entropy ejected to the non-computational state. An analytical derivation based on the definitions of and then shows that the following expression for the convergence of is accurate to first order in , as increases:
And, it’s easy to see that the value of this expression itself approaches 0, almost in proportion to as and . We can then consider applying this observation to each initial state that is not in that merges with some state in . Moreover, for any other states not in that may merge with each other but not with any state in , their individual contributions to the total entropy ejected are upper-bounded by their contributions to the initial computational entropy, where again is their probability, and this as . It is then clear that, as , and the total probability of all of the states satisfying the precondition approaches 1 from below, the total probability of all the states violating the precondition falls to 0, and so does an upper bound on each of their individual probabilities , and thus on each of their contributions to the entropy ejected, and thus (recalling that the state set is finite) their total contribution to the ejected entropy falls to 0, and the theorem holds. ∎
A numerical example illustrating how the calculation comes out in a specific case where the probability of violating the precondition for reversibility is small can be found in , which also discussed the more general issue that the initial-state probabilities must be taken into account in order to properly apply Landauer’s Principle.
Reversals of conditioned reversible operations.
As we saw in Theorem 3.2, any deterministic computational operation is conditionally-reversible with respect to any given one of its suitable preconditions for reversibility. For any computation that satisfies the conditions for reversibility of the conditioned reversible operation with certainty, we can undo the effect of that computation exactly by applying any conditioned reversible operation that is what we call a reversal of . At an intuitive level, the reversal of a conditioned reversible operation is simply an operation that maps the image of the assumed set back onto the assumed set itself in a way that exactly inverts the original forward map. We can define this more formally as follows:
Reversals of conditioned reversible operations. Let be any conditioned reversible operation with assumed set , and let be the image of under . Then a reversal of is any conditioned reversible operation where , and where the image of under is similarly a superset of , and where
That is to say, for any initial computational state in the assumed set , whatever is the final state that maps it to, the operation maps that state back to the original state . In other words, exactly undoes whatever transformation applied to the original assumed set .
The above definitions and theorems can also be extended to work with nondeterministic computations. In fact, adding nondeterminism to an operation only makes it easier to avoid ejecting entropy to the noncomputational state, since nondeterminism tends to increase the computational entropy, and thus tends to reduce the noncomputational entropy. As a result, a nondeterministic operation can be non-entropy-ejecting (or even entropy-absorbing, i.e., with ) even in computations where none of its preconditions for reversibility are satisfied, so long as the reduction in computational entropy caused by its irreversibility is compensated for by an equal or greater increase in computational entropy caused by its nondeterminism. An example of such an operation was given in . However, we will not take the time, in the present paper, to flesh out detailed analyses of such cases.
4 Examples of Conditioned Reversible Operations
In this section, we define and illustrate a number of examples of conditionally-reversible operations (including a specification of their assumed preconditions) that comprise natural primitives to use for the composition of more complex reversible algorithms.
First, we introduce some textual and graphical notations for describing conditioned reversible operations.
First, let the computational state space be factorizable into independent state variables , which are in general -ary discrete variables. Common special cases will be binary variables (). For simplicity, we will assume for purposes of this section that the sets of state variables into which the initial and final computational state spaces are factorized are identical, although more generally this may not be the case. A convenient method for describing conditionally-reversible operations together with their assumed preconditions is to use language specifying initial conditions on the state variables, and how those variables are transformed.
Given a computational state space that is factorizable into state variables , and given a precondition on the initial state defined by
where is some propositional (i.e., Boolean-valued) function of the state variables , we can denote a conditionally-reversible operation on that is reversible under precondition using notation like:
which represents a conditionally-reversible operation named OpName that operates on and potentially transforms the state variables , and that is reversible under an assumed precondition consisting of the set of initial states that satisfy the given proposition .
In the above notation, the proposition for the assumed precondition may sometimes be left implicit and omitted; however, when this is done, readers should keep in mind that any particular device intended to be capable of carrying out a given conditionally reversible operation in an asymptotically physically reversible way will nevertheless necessarily have, built into its design, some particular choice of an assumed precondition with respect to which its physical operation will in fact be asymptotically physically reversible.
A simple, generic graphical notation for a deterministic, conditionally-reversible operation named OpName, operating on a state space that is decomposable into three state variables , and possibly including an assumed precondition for reversibility , is the ordinary space-time diagram representation shown in Fig. 3.
In this representation, as in standard reversible logic networks, time is imagined as flowing from left to right, and the horizontal lines represent state variables. The primed versions going outwards represent the values of the state variables in the final computational state after the operation is completed.
4.2 Reversible set and reset.
As Landauer observed, operations such as “set to one” and “reset to zero” on binary state spaces are logically irreversible, under his definition; indeed, they constitute classic examples of bit erasure operations for which (assuming equiprobable inputs) an amount of entropy is ejected from the computational state. However, as per Theorem 3.2, these operations are in fact conditionally reversible, under suitably-restricted preconditions. A suitable precondition, in this case, is one in which one of the two initial states is required to have probability 0, in which case, the other state must have probability 1. In other words, the initial state is known with certainty in any operating context satisfying such a precondition. A known state can be transformed to any specific new state reversibly. If the new state is different from the old one, such an operation is non-vacuous. Thus, we have the following conditioned reversible operations that are useful:
4.3 Reversible set-to-one (rSET).
The deterministic operation rSET on a binary variable , which (to be useful) is implicitly associated with an assumed precondition for reversibility of , is an operation that is defined to transform the initial state into the final state ; in other words, it performs the operation . Standard and simplified graphical notations for this operation are illustrated in Figure 4.
By Theorem 3.3, the conditioned reversible operation is specifically non-entropy-ejecting in operating contexts where the designated precondition for reversibility is satisfied. It can be implemented in a way that is asymptotically physically reversible (as the probability that its precondition is satisfied approaches 1) using any mechanism that is designed to adiabatically transform the state to the state .
4.4 Reversible reset-to-zero (rCLR).
The deterministic operation rCLR on a binary variable , which (to be useful in a reversible mode) is implicitly associated with an assumed precondition for reversibility of , is an operation that is defined to transform the initial state into the final state ; in other words, it performs the operation . Standard and simplified graphical notations for this operation are illustrated in Figure 5.
Like with , the operation is non-entropy-ejecting when its designated precondition for reversibility is satisfied. It can be implemented in a way that is asymptotically physically reversible (as the probability that its precondition is satisfied approaches 1) using any mechanism that is designed to adiabatically transform the state to the state .
It should be noted that, whenever the precondition for the reversibility of an rSET or rCLR operation is satisfied, the outcome of the operation will be identical to the outcome that would be obtained from a traditional, unconditionally-reversible cNOT (controlled-NOT) operation, ). However, rSET and rCLR may be simpler to implement than cNOT; for example, one can implement them both by simply connecting a circuit node to a voltage reference that then adiabatically transitions between the 0 and 1 logic levels in the appropriate direction. Whereas, to perform an in-place cNOT operation requires more steps than this in an adiabatic switching circuit. E.g., we could first reversibly copy ’s value to a temporary node, then use this to control the charging/discharging of to its new level, then decompute the copy based on the new value of . This illustrates how using the traditional, unconditionally reversible paradigm increases hardware complexity.
4.5 Reversible set-to- (rSET).
Similarly to rSET/rCLR, if we are given a state variable having any higher arity , there are reversible “set to ” operations for larger result values ; however, when , there is a choice among multiple possible non-vacuous preconditions. The general form of the conditioned reversible set-to- operations is thus
where is the assumed initial value of the variable , and is the final value to which it is being set. The graphical notation of ordinary rSET can be generalized appropriately.
4.6 Reversible copy and uncopy.
A very commonly-used computational operation is to copy one state variable to another. As with any other deterministic operation, such an operation will be conditionally reversible, under suitable preconditions. An appropriate precondition for the reversibility of this rCOPY operation is any in which the initial value of the target variable is known, so that it can be reversibly transformed to the new value. A standard reversal of a suitably-conditioned rCOPY operation, which we can call rUnCopy, is simply a conditioned reversible operation that transforms the final states resulting from rCOPY back to the corresponding initial states.
Let be any two discrete state variables both with the same arity (number of possible values, which without loss of generality we may label ), and let be any fixed initial value. Then reversible copy of onto or
is a conditioned reversible operation with assumed precondition that maps any initial state where onto the final state . In the language of ordinary pseudocode, the operation performed is simply .
Given any conditioned reversible copy operation , there is a conditioned reversible operation which we hereby call reversible uncopy of from back to or
which, assuming (as its precondition for reversibility) that initially , carries out the operation , restoring the destination variable to the same initial value that was assumed by the rCOPY operation.
Figure 6 below shows graphical notations for and . It is easy to see that corresponding and operations are reversals of each other, as was intended.
is a reversal of , and vice-versa.
Clear by inspection. ∎
4.7 Reversible general functions.
It is easy to generalize to more complex functions. In general, for any function of any number of variables, we can define a conditioned reversible operation which computes that function, and writes the result to an output variable by transforming from its initial value to , which is reversible under the precondition that the initial value of is some known value . Its reversal decomputes the result in the output variable , restoring it back to the value . See Fig. 7 below.
4.8 Reversible Boolean functions.
It’s important to note here that above may indeed be any function, including standard Boolean logic functions operating on binary variables, such as AND, OR, etc. Therefore, the above scheme leads us to consider conditioned reversible operations such as , , , ; and their reversals , , , ; which reversibly do and undo standard AND and OR logic operations with respect to output nodes that are expected to be a constant logic 0 or 1 initially before the operation is done (and also finally, after doing the reverse operations).
Clearly, one can compose arbitrary functions out of such primitives using standard logic network constructions, and later decompute the results using the reverse (mirror-image) circuits (after rCOPYing the desired results), following the general approach pioneered by Bennett .
One may wonder, however, what is the advantage of using operations such as and compared to the traditional unconditionally reversible operation (controlled-controlled-NOT, a.k.a. the Toffoli gate operation , ). Indeed, any device that implements in a physically-reversible manner could be used in place of a device that implements the conditioned reversible operations and , or one that implements and , in cases where the preconditions of those operations would be satisfied.
But, the converse is not true. In other words, there are asymptotically physically reversible implementations of and that do not also implement full Toffoli gate operations. Therefore, if what one really needs to do, in one’s algorithm, is simply to do and undo Boolean AND operations reversibly, then to insist on doing this using Toffoli operations rather than conditioned reversible operations such as rAND and rUnAND is overkill, and amounts to tying one’s hands with regards to the implementation possibilities, leading to hardware designs that can be expected to be more complex than necessary. Indeed, there are very simple adiabatic circuit implementations of devices capable of performing rAND/rUnAND and rOR/rUnOR operations (based on e.g. series/parallel combinations of CMOS transmission gates, such as in Fig. 8 below), whereas, adiabatic implementations of ccNOT itself are typically much less simple. This illustrates our overall point that the Generalized Reversible Computing framework generally allows for simpler designs for reversible computational hardware than does the traditional reversible computing model based on unconditionally reversible operations.
5 Modeling Reversible Hardware
A final motivation for the study of Generalized Reversible Computing derives from the following observation.
General correspondence between truly, fully adiabatic circuits and conditioned reversible operations. Part (a): Whenever a switching circuit is operated deterministically in a truly, fully adiabatic way (i.e., that asymptotically approaches thermodynamic reversibility), transitioning among some discrete set of logic levels, the computation being performed by that circuit corresponds to a conditioned reversible operation whose assumed precondition is (asymptotically) satisfied. Part (b): Likewise, any conditioned reversible operation can be implemented in an asymptotically thermodynamically reversible manner by using an appropriate switching circuit that is operated in a truly, fully adiabatic way, transitioning among some discrete set of logic levels.
Although we will not here prove Assertion 2 formally, part (a) essentially follows from our earlier observation in Theorem 3.3 that, in deterministic computations, conditional reversibility is the correct statement of the logical-level requirement for avoiding energy dissipation under Landauer’s Principle, and therefore it is a necessity for approaching thermodynamic reversibility in any deterministic computational process, and therefore, more specifically, in the operation of adiabatic circuits.
Meanwhile, part (b) follows simply from general constructions showing how to implement any desired conditioned reversible operation in an asymptotically thermodynamically reversible way using adiabatic switching circuits. For example, Fig. 8 illustrates how to implement an rCOPY operation using a simple four-transistor CMOS circuit. In contrast, implementing rCOPY by embedding it within an unconditionally-reversible cNOT would require including an XOR capability, and would require a much more complicated adiabatic circuit, whose operation would itself be composed from numerous more-primitive operations (such as adiabatic transformations of individual MOSFETs ) that are themselves only conditionally reversible.
In contrast, the traditional reversible computing framework of unconditionally reversible operations does not exhibit any correspondence such as that of Assertion 2 to any natural class of asymptotically physically-reversible hardware that we know of. In particular, the traditional unconditionally-reversible framework does not correspond to the class of truly/fully adiabatic switching circuits, because there are many such circuits that do not in fact perform unconditionally reversible operations, only conditionally-reversible ones.
6 Comparison to Prior Work
The concept of conditional reversibility presented here is similar to, but distinct from, certain concepts that are already well known in the literature on the theory of reversible circuits and languages.
First, the concept of a reversible computation that is only semantically correct (for purposes of computing a desired function) when a certain precondition on the inputs is satisfied is one that was already implicit in Landauer’s original paper , when he introduced the operation now known as the Toffoli gate, as a reversible operation within which Boolean AND may be embedded. Implicit in the description of that operation is that it only correctly computes AND if the program/output bit is initially 0; otherwise, it computes some other function (in this case, NAND). This is the origin of the concept of ancilla bits, which are required to obey certain pre- and post-conditions (typically, being cleared to 0) in order for reversible circuits to be composable and still function as intended. The study of the circumstances under which such requirements may be satisfied has been extensively developed, e.g. as in . However, any circuit composed from Toffoli gates is still reversible even if restoration of its ancillas is violated; it may yield nonsensical outputs in that case, when composed together with other circuits, but at no point is information erased. This distinguishes ancilla-preservation conditions from our preconditions for reversibility, which, when they are unsatisfied, necessarily yield actual (physical) irreversibility.
Similarly, the major historical examples of reversible high-level programming languages such as Janus ([18, 19]), -Lisp , the author’s own R language , and RFUN ([22, 23]) have invoked various “preconditions for reversibility” in the defined semantics of many of their language constructs. But again, that concept really has more to do with the “correctness” or “well-definedness” of a high-level reversible program, and this notion is distinct from the requirements for actual physical reversibility during execution. For example, the R language compiler  generated PISA assembly code in such a way that even if high-level language requirements were violated (e.g., in the case of an if condition changing its truth value during the if body), the resulting assembly code would still execute reversibly, if nonsensically, on the Pendulum processor .
In contrast, the notion of conditional reversibility explored in the present document ties directly to Landauer’s principle, and to the possibility of the physical reversibility of the underlying hardware. Note, however, that it does not concern the semantic correctness of the computation, or lack thereof, and in general, the necessary preconditions for the physical reversibility and correctness of a given computation may be orthogonal to each other, as illustrated by the example in Fig. 8.
In this paper, we have formally presented the core foundations of a general theoretical framework for reversible computing. We analyzed the case of deterministic computational operations in detail, and proved that the class of deterministic computations that are not required to eject any entropy from the computational state under Landauer’s Principle is larger than the set of computations composed of the unconditionally-reversible operations considered by traditional reversible computing theory, because it also includes the set of conditionally-reversible operations whose preconditions for reversibility are satisfied with probability 1 (or asymptotically approaching 1, if we only need the entropy ejected to approach 0). This is, moreover, the most general possible characterization of the set of classical deterministic computations that can be physically implemented in an asymptotically thermodynamically reversible way.
We then demonstrated some applications of the theory by illustrating some basic examples of conditioned reversible operations that work by transforming an output variable between a predetermined, known value and the computed result of the operation. Such operations can be implemented in a very simple way using adiabatic switching circuits, whose computational function cannot in general be represented within the traditional theory of unconditionally-reversible computing. This substantiates our assertion that the generalized reversible computing theory is deserving of significantly greater emphasis than it has so far received.
Some promising directions for future work include: (1) Giving further examples of useful conditioned reversible operations; (2) illustrating detailed physical implementations of devices for performing such operations; (3) further extending the development of the new framework to address the nondeterministic case, in which operations can be non-entropy-ejecting, or even entropy-absorbing, even when none of their preconditions for (logical) reversibility are satisfied; (4) developing further descriptive frameworks for reversible computing at higher levels (e.g., hardware description languages, programming languages) building on top of the fundamental conceptual foundations that GRC theory provides.
The further study and development of Generalized Reversible Computing theory, since it broadens the range of design possibilities for reversible computing devices in a clearly delineated, well-founded way, will be essential if the computing industry is going to successfully transition, over the coming decades, to the point where it is dominantly utilizing the reversible computing paradigm. Due to the incontrovertible validity of Landauer’s Principle, such a transition will be an absolute physical prerequisite in order for the energy efficiency (and cost efficiency) of general computing technology (that is, beyond the few cases that may be substantially sped up by quantum algorithms) to continue growing by indefinitely many orders of magnitude.
- Where is Boltzmann’s constant, and is operating temperature.
- Where is node capacitance, and is logic swing voltage.
- In the language of this paper, the authors of  empirically demonstrate that certain conditionally-reversible operations, which we would refer to as rOR/rNOR, can avoid the Landauer limit, but without realizing that what they are doing is still a form of logically reversible computing, in the generalized sense developed here.
- Boltzmann’s constant is more familiarly defined in terms of energy/temperature units, such as , but another way of understanding the meaning of this formula is simply to say that 1 degree Kelvin of temperature is equivalent to per natural-log unit of entropy. In any case, the identity can be considered to be a simple factual statement that reflects the fundamentally information-theoretic nature of physical entropy.
- International Technology Roadmap for Semiconductors 2.0, 2015 edn., www.semiconductors.org/main/2015_international_technology_roadmap_for_semiconductors_itrs/. Semiconductor Industry Association (2015)
- Landauer, R.: Irreversibility and Heat Generation in the Computing Process. IBM J. Res. Dev. 5(3), 183–191 (1961)
- López-Suárez, M., Neri, I. and Gammaitoni, L.: Sub- micro-electromechanical irreversible logic gate. Nat. Comm. 7, 12068 (2016)
- Likharev, K.: Dynamics of some single flux quantum devices: I. Parametric quantron. IEEE Transactions on Magnetics 13(1), 242-â244 (1977).
- Fredkin, E., Toffoli, T.: Conservative logic. International Journal of Theoretical Physics 21(3â-4), 219-â253 (1982)
- Drexler, K.E.: Nanosystems: Molecular machinery, manufacturing, and computation. John Wiley & Sons, Inc. (1992)
- Younis, S.G., Knight Jr., T.F.: Practical implementation of charge recovering asymptotically zero power CMOS. In: Proceedings of the 1993 Symposium on Research in Integrated Systems, pp. 234–250. MIT Press (1993)
- Frank, M.P.: Approaching the physical limits of computing. In: 35th International Symposium on Multiple-Valued Logic, pp. 168–185. IEEE Press, New York (2005)
- Frank, M.P.: Foundations of Generalized Reversible Computing. In: Phillips, I., Hafizur, R. (eds.) RC 2017. LNCS, vol. 10301, pp. 19–34, Springer, Cham (2017)
- Frank, M.P.: Foundations of generalized reversible computing. Extended author’s preprint of , https://cfwebprod.sandia.gov/cfdocs/CompResearch/docs/grc-rc17-preprint2.pdf, last accessed 6 June 2018.
- Lloyd, S.: Computational Capacity of the Universe. Phys. Rev. Lett. 88, 237901 (2002)
- Zurek, W.H.: Decoherence, einselection, and the quantum origins of the classical. Rev. Mod. Phys. 75(3), pp. 715–775 (2003)
- DeBenedictis, E.P., Frank, M.P., Ganesh, N., Anderson, N.G.: A path toward ultra-low-energy computing. In: IEEE International Conference on Rebooting Computing. IEEE Press, New York (2016)
- Bennett, C. H.: Logical reversibility of computation. IBM J. Res. Dev. 17(6), 525–532 (1973)
- Toffoli, T: Reversible computing. In: International Colloquium on Automata, Languages, and Programming, pp. 632–644. Springer, Berlin (1980)
- Frank, M.P.: Towards a More General Model of Reversible Logic Hardware. Invited talk presented at the Superconducting Electronics Approaching the Landauer Limit and Reversibility (SEALeR) workshop, sponsored by NSA/ARO (2012)
- Thomsen, M.K., Kaarsgaard, R., Soeken, M.: Ricercar: A Language for Describing and Rewriting Reversible Circuits with Ancillae and Its Permutation Semantics. In: Krivine, J., Stefani, J.-B. (eds.) RC 2015. LNCS, vol. 9138, pp. 200-215. Springer International Publishing (2015)
- Lutz, C.: Janus: A time-reversible language. Letter from Chris Lutz to Rolf Landauer, reproduced at http://tetsuo.jp/ref/janus.pdf (1986).
- Yokoyama, T.: Reversible Computation and Reversible Programming Languages. Elec. Notes Theor. Comput. Sci. 253(6), 71–81 (2010)
- Baker, H.G.: NREVERSAL of fortune—The thermodynamics of garbage collection. In: Bekkers Y., Cohen J. (eds.) Memory Management. LNCS, vol. 637, pp. 507–524. Springer, Berlin, Heidelberg (1992)
- Frank, M.: Reversibility for Efficient Computing. Doctoral dissertation, Massachusetts Institute of Technology, Dept. of Elec. Eng. and Comp. Sci. (1999)
- Yokoyama, T., Axelsen, H.B., Glück, R.: Towards a Reversible Functional Language. In: De Vos, A., Wille, R. (eds.) RC 2011. LNCS, vol. 7165, pp. 14–29. Springer, Berlin, Heidelberg (2012)
- Axelsen, H.B., Glück R.: Reversible Representation and Manipulation of Constructor Terms in the Heap. In: Dueck, G.W., Miller, D.M. (eds.) RC 2013. LNCS, vol. 7948, pp. 96–109. Springer, Berlin, Heidelberg (2013)
- Vieri, C.J.: Reversible Computer Engineering and Architecture. Doctoral dissertation, Massachusetts Institute of Technology, Dept. of Elec. Eng. and Comp. Sci. (1999)