Quantum Reversibility and a New Model of Quantum Automaton

Quantum reversibility and a new model of quantum automaton Massimo Pica Ciamarra Dipartimento di Scienze Fisiche, Universitàdi Napoli “Federico II”, Napoli, Italy. E-mail: [email protected] Abstract This article is an attempt to generalize the classical theory of reversible computing, principally developed by Bennet [IBM J. Res. Develop., 17(1973)] and by Fredkin and Toffoli [Internat. J. Theoret. Phys., 21(1982)], to the quantum case. This is a fundamental step towards the construction of a quantum computer because a time efficient quantum computation is a reversible physical process. The paper is organized as follows. The first section reviews the classical theory of reversible computing. In the second section it is showed that the designs used in the classical framework to decrease the consumption of space cannot be generalized to the quantum case; it is also suggested that quantum computing is generally more demanding of space than classical computing. In the last section a new model of fully quantum and reversible automaton is proposed. The computational power of this automaton is at least equal to that of classical automata. Some conclusion are drawn in the last section. arXiv:quant-ph/0102104v1 21 Feb 2001 1 Reversible computing: a glance The classical theory of reversible computing has been analyzed extensively ([2, 3]). The main results are the following: 1. Every irreversible computation f : x → f(x) can be effectively enclosed in a reversible computation F : (x, 0) → (f(x), x). F is reversible because its input (x, 0) is uniquely determined by its output (f(x), x). 2. The time and space required to compute F are linearly dependent on those required to compute f. These results imply that there are no effects on the complexity hierarchy when the time and space required to compute f are those required to compute its reversible realization F (reversible space equal irreversible space). To investigate whether is it possible to extend the above classical results to the quantum case, we first revisit the ideas behind classical reversible computing. 1 1.1 Reversible gates In order to transform an irreversible gate into a reversible one, not only the gate computation result is to be codified in the gate output, but also some other information necessary to reverse the computation (garbage). To store the garbage more output lines are needed and, since a reversible gate has the same numbers of input and output lines, even more input lines are required (source). Note that, since reversibility implies that the output of a reversible gate depends on the state of the source, its state has to be properly set to compute a given boolean function by a reversible gate. Figure 1 here below outlines the logical structure of a reversible gate. source output input garbage Figure 1: Logical structure of a reversible gate Example: Reversible AND gate. The AND gate is a two-input one-output gate, whereas its reversible realization is a three-input three-output gate. The adjunctive input line (s) constitutes the source and the two adjunctive output lines (g1 and g2) are the garbage. The transition function of the reversible AND gate is reported in Table 1. Table 1: Reversible AND gate s i1 i2 AND g1 g2 0 0 0 0 00 0 0 1 0 01 0 1 0 0 10 0 1 1 1 11 Table 1 could be completed by adding the three possible inputs with s = 1. In this case, however, reversibility implies that the gate does not realize the AND function. As 2 already remarked, to use a reversible gate the value of the source lines must be prepared appropriately. 1.2 Reversible combinatorial circuits To build up a reversible combinatorial circuit (i.e. a circuit without loop) from an irreversible one, every gate can be replaced by its reversible realization (that is, every boolean function is computable by a reversible circuit). However, although the final circuit works, it often has too many source and garbage lines. In fact [3]: Note that, in general, (in a combinatorial circuit) the number of gates in- creases exponentially with the number of input lines. This is so because almost all Boolean functions are “random”, i.e., cannot be realized by a circuit simpler than one containing an exhaustive look-up table. Thus, in the “wasteful” approach the amount of garbage grows exponentially with the size of the argument. This explains why a reversible realization of a combinatorial circuit seems less efficient than the combinatorial circuit itself with regard to space consumption. Actually, in classical case there is a way to recycle the garbage that implies a linear relation be- tween the space required to compute a boolean function by a reversible or irreversible computation. This process, outlined in Figure 2, rests on two considerations: 1. An inverse circuit exists for every reversible circuit, and 2. A copy circuit: (x, 0) → (x, x) does exist. source 0 garbage source 0 input x FFf(x) f(x) -1 input x Copy source 0 f(x) Figure 2: Reversible combinatorial circuit with garbage recycle To be honest, the above process is really useful only when applied in a nested fashion. 1.3 Reversible sequential circuits If the output lines of a combinatorial circuit are used as input lines, one ends up with a sequential circuit (finite automaton), as outlined in Figure 3. A sequential circuit 3 constantly works in (discrete) interaction with the environment, that changes the state of the input lines. Its evolution is a three-step loop starting from a given internal state: 1. The environment sets the value of the input lines. 2. The combinatorial circuit (i.e. the transition function) is computed. 3. Some output lines are used as input lines (they codify the new internal state). By substituting the combinatorial part of a sequential circuit for its reversible realization one does not end up with a reversible sequential circuit. In fact, every time the combinatorial circuit (transition function) is computed, the garbage is modified and the information necessary to reverse the computation is lost. Therefore, in order to build up a reversible sequential circuit, every time the transition function is computed the produced garbage has to be registered. In the following section we present a scheme of sequential circuits, or finite automata, that is able to register the output and the garbage appropriately. 1.4 Reversible Turing machines Bennet [2] has proposed an effective procedure that transforms every irreversible one- tape Turing machine into a reversible three-tape Turing machine. The computation of this machine, that recycles the garbage with the same trick used by reversible combinatorial circuits (Fig. 2), proceeds as follows: 1. Initially the three tapes contain input-source-source. The reversible function is computed. 2. The tapes contain garbage-result-source. The 2nd tape result is copied on the 3rd tape. 3. The tapes contain garbage-result-result. The inverse reversible function is computed. 4. The tapes contain input-source-result. 2 Space consumption of quantum computing 2.1 Space consumption of reversible computing In the classical framework we seldom care about space consumption. In fact, since P − T ime ⊆ P − Space = NP − Space ⊆ Exp − T ime, we first have to trouble about time consumption. This relation stems from the fact that if a computation needs some space, then it needs also some time to use it. Therefore every consumption of space requires a consumption of time, whereas the consumption of time does not implies a consumption of space. 4 In the case of reversible computing, not only every consumption of space requires a consumption of time, but also every consumption of time requires a consumption of space. In fact every unit of time, that corresponds to the execution of an elementary step, as a (reversible) gate or a transition of a (reversible) Turing machine, requires its own source. Time and space seem to be strictly tied. Let T and S be the time and space required by an irreversible Turing machine to end its computation, supposing that the machine halts, and let T ′ and S′ be the time and space that its reversible realization does need. Then exists such c > 1 that T ′ ≃ c + cT and S′ ≃ c + c(S + T ) [2]. From a computational complexity point of view this suggests that reversible and irreversible computation differ. In fact S′ = O(S + T ): if an irreversible computation is space efficient but time inefficient, then its reversible simulation is both time and space inefficient. However, as we saw in the previous section, Bennet has proposed a way to reduce the amount of space the reversible simulation requires. His scheme has been improved overtime [5], and today we know that reversible and irreversible computation have the same complexity, i.e. T ′ ≃ O(T ) and S′ ≃≃ S2). The consumption of space of a reversible computation does not depend on the consumption of time of the irreversible one. This result is appreciated because, although the need of space S′ ≃ c + c(T + S) does not generally imply that the reversible computation is space inefficient, nevertheless it can be an unacceptable amount of space for many practically computations [5]. 2.2 The quantum case The design proposed to recycle the garbage relies on the possibility of retracing the computation, once duplicated the result. In the quantum framework this design does not work because of the no cloning theorem: it is not possible to make a copy of the state of a quantum system. This is especially true for a quantum computation that is more efficient than a classical one, for it uses superposition states.

Load more