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

The Abrams-Lloyd quantum algorithm computes an eigenvalue and the corresponding eigenstate of a unitary matrix from an approximate eigenvector V a . 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 V a 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 sequencewithout repetitions. An operator that anticommuteswith 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.


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.

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 where = 2 . The operator is conditionally applied to | ⟩ so that 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): Using (3), (4), and (5), (2) is written as follows: Recall the inverse quantum Fourier transform (QFT −1 ) [6]: If the number of qubits is such that 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: The index register, when measured, gives the value with probability | | 2 . 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].

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.

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 | 0 ⟩ is the eigenvector computed by Abrams-Lloyd algorithm using the computational basis state |0⟩, then choosing |1⟩ as the next approximate eigenvector can yield | 0 ⟩ itself as ⟨1| 0 ⟩ need not be zero.

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 .

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 | 1 ⟩ be the current state of the qubit that we wish to orthogonalize. Our aim is to find an operator such that ⟨ 1 | | 1 ⟩ = 0. Assume to be the unitary single qubit operator whose eigenvector is | 1 ⟩. If the operators and anticommute, will orthogonalize | 1 ⟩.

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 : with ⟨ | ⟩ = .
Let operating on | 1 ⟩ result in a state that can in general be expanded in terms of the eigen basis states | ⟩: As and anticommute, = − . Then, Equating the | 1 ⟩ components of (14) and (15), This happens only when each side is equal to zero. Since 1 , being the eigenvalue of a unitary operator, cannot be zero, 1 has to be zero, which means that (12) simplifies to The operator orthogonalizes | 1 ⟩.

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 |V 1 ⟩. Let |V 2 ⟩ be the orthogonal eigenvector (⟨V 1 |V 2 ⟩ = 0). Let |V ⟩ = |V 1 ⟩. If ⟨V 1 |V ⟩ = 0, then is a perfect orthogonalizer. If ⟨V 1 |V ⟩ = 1/ √ 2, then |V ⟩ has equal measures of |V 1 ⟩ and |V 2 ⟩. So, a good orthogonalizer should give ⟨V 1 |V ⟩ 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.
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.

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 Table 3, and the eigenvalues are shown in Table 4. Both are computed numerically: 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 1 . The corresponding eigenvector is seen (in of the simulated quantum computer) as 0.70711(|0⟩ + |2⟩). This is | 1 ⟩. Hadamard operator , for nonorthogonalization, is then applied to and the Abrams-Lloyd algorithm steps are carried out stopping short of the last measurement.
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.

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 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 .

Numerical
Abrams