Preparation of Approximate Eigenvector by Unitary Operations on Eigenstate in Abrams-Lloyd Quantum Algorithm

Abstract

The Abrams-Lloyd quantum algorithm computes an eigenvalue and the corresponding eigenstate of a unitary matrix from an approximate eigenvector 𝑉_𝑎. The eigenstate is a basis vector in the orthonormal eigenspace. Finding another eigenvalue, using a random approximate eigenvector, may require many trials as the trial may repeatedly result in the eigenvalue measured earlier. We present a method involving orthogonalization of the eigenstate obtained in a trial. It is used as the 𝑉_𝑎 for the next trial. Because of the orthogonal construction, Abrams-Lloyd algorithm will not repeat the eigenvalue measured earlier. Thus, all the eigenvalues are obtained in sequence without repetitions. An operator that anticommutes with a unitary operator orthogonalizes the eigenvectors of the unitary. We implemented the method on the programming language model of quantum computation and tested it on a unitary matrix representing the time evolution operator of a small spin chain. All the eigenvalues of the operator were obtained sequentially. Another use of the first eigenvector from Abrams-Lloyd algorithm is preparing a state that is the uniform superposition of all the eigenvectors. This is possible by nonorthogonalizing the first eigenvector in all dimensions and then applying the Abrams-Lloyd algorithm steps stopping short of the last measurement.

1. Introduction

Calculation of eigenvalues and eigenvectors of the Hamiltonian operator is one of the most frequent problems of physics. Most of the classical algorithms require an exponential amount of time for this. However, not all eigenvalues are of physical interest, but only few lower lying ones. Abrams and Lloyd’s quantum algorithm [1], considered to be the most important [2] quantum algorithm known so far, computes an eigenvalue of a unitary operator, or specifically the time evolution operator 𝑈, in polynomial time. The eigenvalues of unitary operator lie around the unit circle on complex plane.

Abrams-Lloyd algorithm starts with an approximation to the eigenvector. Normally, it is the result of a classical calculation. The algorithm needs two quantum registers. The first, an index register, is prepared in a uniform superposition of all the computational basis states. The second, a target register, is prepared with approximate eigenvector. After the application of Abrams-Lloyd algorithm, the eigenvalue is calculated from the measurement on the index register. The corresponding eigenstate is in the target register but is not measured.

There are three disadvantages with the approximation. First, if the component of an eigenstate in the approximate eigenvector is small, then many trials and measurements will be needed to get the eigenvalue. Second, there is no advice on how to select the approximate eigenvector containing important eigenstates. Third, if an eigenvalue measured by Abrams-Lloyd algorithm is the same as the one obtained earlier, then without seeing the eigenstates, it is not possible to say whether the eigenvalue is a repeat of the previous or is a degenerate eigenvalue with a different eigenstate.

A method based on coarse and fine grids [3] gets a good approximate eigenvector 𝑉_𝑎 for Abrams-Lloyd algorithm. It still does not solve the problem of repeated eigenvalues. An iterative approximation method using perturbation series for the eigenvectors and the eigenvalues is presented in [4], but it is not a quantum algorithm. A recursive quantum algorithm by Bang et al. [5] finds the lowest eigenstate of a general Hamiltonian. The algorithm too starts with a suitably chosen initial state. This state should not be orthogonal to the lowest eigenstate. A series of transformations are applied to the initial state. These transformations amplify the amplitude of the lowest eigenstate. The lowest eigenvalue can then be extracted from the iterated state by an application of the Abrams-Lloyd algorithm.

The Abrams-Lloyd algorithm transforms the approximate eigenvector to an actual eigenvector. Can we use this eigen state to obtain a better approximate eigenvector for another iteration of Abrams-Lloyd algorithm? The eigenvectors of a normal matrix are orthonormal. Thus, the first eigenvector, obtained by Abrams-Lloyd algorithm gives a handle to the orthonormal eigen-space. By sequentially orthogonalizing the eigen vectors, we get the other eigenvalues in sequence. If we nonorthogonalize the eigenvector in all the dimensions, we get a state that is not orthogonal to any eigenstate. In other words, we get a state containing all the eigenstates. This can now be used as the initial state for the Bang et al. algorithm [5] as it contains the lowest eigenstate.

2. Abrams and Lloyd Quantum Algorithm and the Approximate Eigenvector

Abrams-Lloyd algorithm needs an index register of 𝑚 qubits for the eigenvalue. A target register of 𝑙 qubits is for the eigenvector. The index register is prepared as a superposition of the basis states and the target register, as the approximate eigenvector |𝑉_𝑎⟩. Thus, the initial state is given by |Ψ⟩=1√𝑀^𝑀−1_𝑗=0𝑗𝑉_𝑎, (1) where 𝑀=2^𝑚. The operator 𝑈 is conditionally applied to |𝑉_𝑎⟩ so that |Ψ⟩=1√𝑀^𝑀−1_𝑗=0𝑗(𝑈)^𝑗𝑉_𝑎. (2)

The state |Ψ⟩ can be rewritten with, |𝑉_𝑎⟩ expanded in terms of its component eigenvectors |𝜙_𝑘⟩ (3), eigenvalue equation (4) and the fact that the eigenvalues of the unitary matrices are roots of unity (5): 𝑉_𝑎=_𝑘𝑐_𝑘𝜙_𝑘,𝑈𝜙_𝑘=𝜆_𝑘𝜙_𝑘,𝜆_𝑘=𝑒^{−𝑖𝜔𝑘}. (3)(4)(5) Using (3), (4), and (5), (2) is written as follows: |Ψ⟩=_𝑘1√𝑀^𝑀−1_𝑗=0𝑒^{−𝑖𝜔𝑘𝑗}𝑗𝑐_𝑘𝜙_𝑘. (6) Recall the inverse quantum Fourier transform (QFT⁻¹) [6]: |𝑘⟩⟼1√𝑀^𝑀−1_𝑗=0𝑒^{−𝑖(2𝜋/𝑀)𝑘𝑗}𝑗. (7) If the number of qubits 𝑚 is such that 𝜔_𝑘=2𝜋𝑘𝑀 (8) we see that the index register is the inverse Fourier transformed state in (7). By taking a QFT of the index register, one gets the quantum state as follows: |Ψ⟩=_𝑘(|𝑘⟩)𝑐_𝑘𝜙_𝑘=_𝑘𝑐_𝑘|𝑘⟩𝜙_𝑘. (9) The index register, when measured, gives the value 𝑝 with probability |𝑐_𝑝|². The quantum state collapses to |𝑝⟩|𝜙_𝑝⟩. The eigenvalue is computed as 𝑒^{−𝑖(2𝜋/𝑀)𝑝}. The corresponding eigenvector is in the other register as |𝜙_𝑝⟩.

When the condition (8) does not hold, Abrams and Lloyd algorithm still finds the eigenvalues with accuracy scaling linearly with 𝑀 [1].

2.1. Choosing the Approximate Eigenvector

Both the Abrams-Lloyd and the Bang et al. algorithms require that the initial approximate eigenvector has a nontrivial component of the interesting eigenvectors. Even if we roughly know the important eigenvector, we have to prepare 𝑉_𝑎 in the state with suitable unitary operations. This is not trivial.

A uniform superposition of all computational basis states as the initial 𝑉_𝑎 is a better option. It is easily realized by the application of the Hadamard operator on the target register in state |0⟩. Even then, there is no guarantee that the 𝑉_𝑎 register contains a component of the important eigenvectors. But Abrams-Lloyd algorithm will then give at least one eigenvalue 𝜆_𝑝 and the corresponding eigenvector |𝜙_𝑝⟩. This eigenvector could be gainfully used to generate a better approximate eigenvector.

If the objective is to get another eigenvalue, then the next 𝑉_𝑎 should not have a component of the eigenvector obtained earlier. An orthogonalization operator is applied to |𝜙_𝑝⟩ to transform it to |𝜙_𝑝^⟂⟩ such that ⟨𝜙_𝑝^⟂|𝜙_𝑝⟩ is 0. |𝜙_𝑝^⟂⟩ is the 𝑉_𝑎 for the next calculation. Since the new 𝑉_𝑎 does not have a component of |𝜙_𝑝⟩ because of the orthogonal construction, Abrams-Lloyd algorithm on it will not repeat the earlier eigenvalue 𝜆_𝑝 but will result in a different eigenvalue and eigenvector. The procedure can be repeated till all the eigenvectors are determined. Since the eigenvectors of unitary operators are orthogonal, the eigenvector obtained through orthogonalization can be a true eigenvector and not an approximate one. Abrams-Lloyd algorithm on this will give the corresponding eigenvalue.

If the aim is to obtain a 𝑉_𝑎 having the important eigenvectors, a simple method would be to force it to have all the eigenvectors. Again, this could be obtained from the |𝜙_𝑝⟩, but by nonorthogonalizing it in the orthonormal eigen space.

2.2. Orthogonalization of Eigenvector

The eigenvector in the Abrams-Lloyd method is in the target register of 𝑙 qubits. If it is in a product state, a single qubit orthogonalization operator applied to any one of the 𝑙 qubits will give rise to an 𝑙 qubit state orthogonal to the original state. Subsequently, the single qubit orthogonalization operator can be applied to another qubit. Considering the target register to be of 3 qubits (𝑙=3), the sequence of states, as a result of the single qubit orthogonalizations, can be represented as |000⟩→|001⟩→|011⟩→|111⟩→|101⟩→|100⟩→|110⟩→|010⟩. The position of the changed bit between successive values of this index variable indicates which qubit is orthogonalized. It is easily seen that each state is orthogonal to the rest and any sequential state is the result of a single qubit orthogonalization. Such a sequential evaluation of the eigenvalues is unlikely to result in the important ones fast. The choice of which qubit is to be orthogonalized should be more sophisticated.

It is tempting to think that the computational basis states can be used sequentially as the approximate eigenvector. The drawback is easily seen. If |𝜙₀⟩ is the eigenvector computed by Abrams-Lloyd algorithm using the computational basis state |0⟩, then choosing |1⟩ as the next approximate eigenvector can yield |𝜙₀⟩ itself as ⟨1|𝜙₀⟩ need not be zero.

2.3. Nonorthogonalization

The state obtained after the application of Abrams-Lloyd algorithm is a basis state in the orthonormal eigen basis. Rotation of each computational basis of this eigenstate by 𝜋/2 will result in a state that is not orthogonal to each of the orthonormal eigen basis states. In other words, the new state will overlap with all the eigenvectors. Rotation by 𝜋/2 is the same as the Hadamard operation. Since all the eigen basis states have to be nonorthogonalized, all the qubits of the 𝑉_𝑎 can be operated on by 𝐻.

2.4. Orthogonalization Operator

It is interesting to analyse whether there exists any relationship between the orthogonalising operator and the unitary operator whose eigenstates are to be orthogonalized. It is obvious that they should not commute as commuting operators have simultaneous eigenvectors. The operators that do not commute too may not orthogonalize. Can we find a set of operators that will indeed orthogonalize?

Let |𝜓₁⟩ be the current state of the qubit that we wish to orthogonalize. Our aim is to find an operator 𝑂 such that ⟨𝜓₁|𝑂|𝜓₁⟩=0. Assume 𝑈 to be the unitary single qubit operator whose eigenvector is |𝜓₁⟩. If the operators 𝑈 and 𝑂 anticommute, 𝑂 will orthogonalize |𝜓₁⟩.

Theorem 1. Given a unitary operator 𝑈 and an operator 𝑂 that anticommutes with 𝑈, then 𝑂 will orthogonalize the eigenvectors of 𝑈.

Proof. Consider 𝑈 and 𝑂 to be single qubit operators. Let |𝜓_𝑗⟩ be the eigenvector of 𝑈 with eigenvalue 𝜆_𝑗. The dimension of 𝑈 is 𝑀. So, 𝑗 will range from 1 to 𝑀: 𝑈𝜓_𝑗=𝜆_𝑗𝜓_𝑗 (10) with 𝜓_𝑖∣𝜓_𝑗=𝛿_𝑖𝑗. (11)
Let 𝑂 operating on |𝜓₁⟩ result in a state that can in general be expanded in terms of the eigen basis states |𝜓_𝑗⟩: 𝑂𝜓₁=𝑤₁𝜓₁+^𝑀_𝑗=2𝑤_𝑗𝜓_𝑗. (12)
As 𝑂 and 𝑈 anticommute, 𝑂𝑈=−𝑈𝑂. Then, 𝑂𝑈𝜓₁=−𝑈𝑂𝜓₁,𝑂𝑈𝜓₁=𝑂𝜆₁𝜓₁=𝜆₁𝑂𝜓₁=𝜆₁𝑤₁𝜓₁+^𝑀_𝑗=2𝑤_𝑗𝜓_𝑗,−𝑈𝑂𝜓₁=−𝑈𝑤₁𝜓₁+^𝑀_𝑗=2𝑤_𝑗𝜓_𝑗=−𝑤₁𝜆₁𝜓₁+^𝑀_𝑗=2𝑤_𝑗𝜆_𝑗𝜓_𝑗. (13)(14)(15)
Equating the |𝜓₁⟩ components of (14) and (15), 𝑤₁𝜆₁𝜓₁=−𝑤₁𝜆₁𝜓₁,𝑤₁𝜆₁=−𝑤₁𝜆₁. (16)
This happens only when each side is equal to zero. Since 𝜆₁, being the eigenvalue of a unitary operator, cannot be zero, 𝑤₁ has to be zero, which means that (12) simplifies to 𝑂𝜓₁=^𝑀_𝑗=2𝑤_𝑗𝜓_𝑗,𝜓₁|𝑂|𝜓₁=𝜓₁^𝑀_𝑗=2𝑤_𝑗𝜓_𝑗=^𝑀_𝑗=2𝑤_𝑗𝜓₁∣𝜓_𝑗=0. (17) The operator 𝑂 orthogonalizes |𝜓₁⟩.

2.5. Single Qubit Orthogonalization Operators

The anticommuting property rigorously specifies the orthogonalizer. Let us measure the effectiveness in orthogonalization of some well-known operators that may not anticommute. Let us investigate how close an operator 𝑃 will orthogonalize an eigenvector |𝑣₁⟩. Let |𝑣₂⟩ be the orthogonal eigenvector (⟨𝑣₁|𝑣₂⟩=0). Let |𝑣_𝑝⟩=𝑃|𝑣₁⟩. If ⟨𝑣₁|𝑣_𝑝⟩=0, then 𝑃 is a perfect orthogonalizer. If ⟨𝑣₁|𝑣_𝑝⟩=1/√2, then |𝑣_𝑝⟩ has equal measures of |𝑣₁⟩ and |𝑣₂⟩. So, a good orthogonalizer 𝑃 should give ⟨𝑣₁|𝑣_𝑝⟩ to be close to 0 or at least less than 1/2.

A single qubit orthogonalization operator for states with real amplitudes is 𝑖𝜎_𝑦 where 𝜎_𝑦 is the Pauli spin operator. When the state has complex amplitudes, the operator does not exactly orthogonalize it, and the inner product can have a nonzero imaginary component. If the state has a complex amplitude that can be factored out, resulting in a state with real amplitudes multiplied by the complex factor, 𝑖𝜎_𝑦 will be an exact orthogonalization operator. Table 1 shows some of the promising operators and their level of orthogonalisation.

Table 1 

Some single qubit orthogonalisation operators suitable for various types of eigenvectors.

We wish to exactly orthogonalize, but, because of the complex amplitudes or nonproduct form of the obtained eigenvector, we may end up with a quasi orthogonal approximate eigenvector. The Abrams-Lloyd algorithm will then, without certainty, result in new eigenvalues and eigenvectors for these approximations.

3. Calculation and Results

3.1. Sequential Computation of Eigenvalues

We have tested our method with a 6×6𝐻 matrix obtained from a spin Hamiltonian for a 4-spin chain with total spin zero. The eigenvalues and eigenvectors of 𝐻 can be calculated numerically, and the eigenvalues are shown in Table 2. For Abrams-Lloyd algorithm with orthogonalization, we first construct the unitary matrix 𝑈=𝑒^{−𝑖𝜏𝐻} with 𝜏=1. The initial approximate eigenstate 𝑉_𝑎 is a uniform superposition of 3 qubits. All the six eigenvalues, including three degenerate ones, were obtained in sequential trials and without repetition. The computation is implemented again on QCL. The 6×6𝑈 matrix is embedded in an 8×8 unit matrix so that it operates on the state of 3 qubits. Table 2 shows the comparison of results: ,,𝐻=00000.50.500000.50.500000.50.500000.50.50.50.50.50.5−100.50.50.50.50−1𝑈=𝑎𝑏𝑏𝑏𝑐𝑐𝑏𝑎𝑏𝑏𝑐𝑐𝑏𝑏𝑎𝑏𝑐𝑐𝑏𝑏𝑏𝑎𝑐𝑐𝑐𝑐𝑐𝑐𝑑𝑓𝑐𝑐𝑐𝑐𝑓𝑑 (18) where (),(),(),(),().𝑎=0.805372−0.0644704𝑖𝑏=−0.194629−0.0644704𝑖𝑐=0.159408−0.291795𝑖𝑑=0.221486+0.583589𝑖𝑓=−0.318816−0.257881𝑖 (19)

Table 2 

Comparison of eigenvalues obtained numerically and through Abrams-Lloyd quantum algorithm sequentially. The approximate eigenvector is obtained by orthogonalization of eigenstate of 3 qubits. The single qubit orthogonalization operator is 𝑖𝜎_𝑦. The index register of 5 qubits (𝑀=32) is measured as 𝑝.

3.2. Computation of Initial State with All Eigenvalues

The method to generate a state containing all the eigenvectors is tested on a unitary matrix 𝑈 (20). The eigenvectors of 𝑈 are shown in Table 3, and the eigenvalues are shown in Table 4. Both are computed numerically: 𝑈=𝑎0𝑏00−𝑏^∗0𝑎^∗𝑏0𝑎00𝑎^∗0−𝑏^∗, (20) where (),().𝑎=0.85355−0.35355𝑖𝑏=0.14645+0.35355𝑖 (21)

Table 3 

The eigenvectors |𝜙_𝑛⟩ of 𝑈 in (21). 𝑡=1/√2.

Table 4 

The eigenvalues |𝜆_𝑛⟩ of 𝑈 in (21). 𝑡=1/√2.

For this unitary matrix, we allocate an index register of 3 qubits. For the 𝑉_𝑎, 2 qubits are sufficient. After the first application of Abrams-Lloyd algorithm, the eigenvalue is measured in the index register as 0 and computed as 𝜆₁. The corresponding eigenvector is seen (in 𝑉_𝑎 of the simulated quantum computer) as 0.70711(|0⟩+|2⟩). This is |𝜙₁⟩. Hadamard operator 𝐻, for nonorthogonalization, is then applied to 𝑉_𝑎 and the Abrams-Lloyd algorithm steps are carried out stopping short of the last measurement.

The simulated quantum state is seen as 0.35356(|0⟩(|0⟩+|2⟩)−|1⟩(|1⟩+|3⟩)−|4⟩(|1⟩−|3⟩)+|7⟩(|0⟩−|2⟩)). This is the same state as 0.5(|0⟩|𝜙₁⟩−|1⟩|𝜙₀⟩−|4⟩|𝜙₂⟩+|7⟩|𝜙₃⟩). Thus, the quantum state is in a uniform superposition of all eigenvectors.

3.3. Discussion

The eigenvalues obtained using Abrams-Lloyd algorithm are not the exact eigenvalues (Table 2), but this difference is because of the precision of the index quantum register of 5 qubits and not due to the approximate eigenvector obtained through orthogonalization. The orthogonalization deterministically gives all the eigenvalues. Without this, it would be difficult to obtain all the eigenvalues, as a poorly constructed approximate eigenvector can result in an eigenvalue measured earlier.

4. Conclusion

The Abrams-Lloyd quantum algorithm computes an eigenstate of a unitary operator whatever be the initial approximate eigenvector. This eigenvector is a basis vector in the orthonormal eigen space. Orthogonalization of this eigenvector, followed by Abrams-Lloyd algorithm, can result in the other eigenvalues without repetitions. Simple sequential orthogonalization of a qubit of the eigenvector at a time gives the eigenvalues sequentially, but better methods of choosing the qubits are needed so that important eigenvalues are obtained. The nonorthogonalization of the first eigenvector obtained using Abrams-Lloyd algorithm results in a state with all the eigenvectors and the corresponding eigenvalues. This state is then a suitable candidate for amplitude amplification algorithms like the Bang et al. algorithm.

Acknowledgments

The author acknowledges the financial and management support provided by the Department of Science and Technology (DST), Goverment. of India, through the Women Scientist Scheme-A (SR/WOS-A/PS-19/2009) to carry out this work. The author is thankful to K. Vinod Kumar, C-DAC, Mumbai, for the help in the computation. The author is grateful to the referee, whose valuable comments led her to characterizing the orthogonalization operator.