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

Authors: Latha S. Warrier
Journal: Journal of Computational Methods in Physics
 (2013)

---

## Abstract

The Abrams-Lloyd quantum algorithm computes an eigenvalue and the corresponding eigenstate of a unitary matrix from an approximate eigenvectorVa. 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 Va 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.


---

## Body

## 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 U, 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 Va 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 ofm qubits for the eigenvalue. A target register of l 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 |Va〉. Thus, the initial state is given by
(1)|Ψ〉=1M∑j=0M-1‍|j〉|Va〉,
where M=2m. The operator U is conditionally applied to |Va〉 so that
(2)|Ψ〉=1M∑j=0M-1‍|j〉(U)j|Va〉.The state|Ψ〉 can be rewritten with, |Va〉 expanded in terms of its component eigenvectors |ϕk〉 (3), eigenvalue equation (4) and the fact that the eigenvalues of the unitary matrices are roots of unity (5):
(3)|Va〉=∑k‍ck|ϕk〉,(4)U|ϕk〉=λk|ϕk〉,(5)λk=e-iωk.
Using (3), (4), and (5), (2) is written as follows:
(6)|Ψ〉=∑k‍(1M∑j=0M-1‍e-iωkj|j〉)(ck|ϕk〉).
Recall the inverse quantum Fourier transform (QFT-1) [6]:
(7)|k〉⟼1M∑j=0M-1‍e-i(2π/M)kj|j〉.
If the number of qubits m is such that
(8)ωk=2πkM
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)|Ψ〉=∑k‍(|k〉)(ck|ϕk〉)=∑k‍ck|k〉|ϕk〉.
The index register, when measured, gives the value p with probability |cp|2. The quantum state collapses to |p〉|ϕp〉. The eigenvalue is computed as e-i(2π/M)p. The corresponding eigenvector is in the other register as |ϕp〉.When the condition (8) does not hold, Abrams and Lloyd algorithm still finds the eigenvalues with accuracy scaling linearly with M [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 prepareVa in the state with suitable unitary operations. This is not trivial.A uniform superposition of all computational basis states as the initialVa 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 Va register contains a component of the important eigenvectors. But Abrams-Lloyd algorithm will then give at least one eigenvalue λp and the corresponding eigenvector |ϕp〉. This eigenvector could be gainfully used to generate a better approximate eigenvector.If the objective is to get another eigenvalue, then the nextVa should not have a component of the eigenvector obtained earlier. An orthogonalization operator is applied to |ϕp〉 to transform it to |ϕp⊥〉 such that 〈ϕp⊥|ϕp〉 is 0. |ϕp⊥〉 is the Va for the next calculation. Since the new Va does not have a component of |ϕp〉 because of the orthogonal construction, Abrams-Lloyd algorithm on it will not repeat the earlier eigenvalue λp 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 aVa having the important eigenvectors, a simple method would be to force it to have all the eigenvectors. Again, this could be obtained from the |ϕp〉, 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 ofl qubits. If it is in a product state, a single qubit orthogonalization operator applied to any one of the l qubits will give rise to an l 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 (l=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.


### 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 Va can be operated on by H.


### 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|ψ1〉 be the current state of the qubit that we wish to orthogonalize. Our aim is to find an operator O such that 〈ψ1|O|ψ1〉=0. Assume U to be the unitary single qubit operator whose eigenvector is |ψ1〉. If the operators U and O anticommute, O will orthogonalize |ψ1〉.Theorem 1.
Given a unitary operatorU and an operator O that anticommutes with U, then O will orthogonalize the eigenvectors of U.Proof.
ConsiderU and O to be single qubit operators. Let |ψj〉 be the eigenvector of U with eigenvalue λj. The dimension of U is M. So, j will range from 1 to M:
(10)U|ψj〉=λj|ψj〉
with
(11)〈ψi∣ψj〉=δij.
LetO operating on |ψ1〉 result in a state that can in general be expanded in terms of the eigen basis states |ψj〉:
(12)O|ψ1〉=w1|ψ1〉+∑j=2M‍wj|ψj〉.
AsO and U anticommute, OU=-UO. Then,
(13)OU|ψ1〉=-UO|ψ1〉,(14)OU|ψ1〉=Oλ1|ψ1〉OU|ψ1〉=λ1O|ψ1〉OU|ψ1〉=λ1(w1|ψ1〉+∑j=2M‍wj|ψj〉),(15)-UO|ψ1〉=-U(w1|ψ1〉+∑j=2M‍wj|ψj〉)-UO|ψ1〉=-(w1λ1|ψ1〉+∑j=2M‍wjλj|ψj〉).
Equating the|ψ1〉 components of (14) and (15),
(16)w1λ1|ψ1〉=-w1λ1|ψ1〉,w1λ1=-w1λ1.
This happens only when each side is equal to zero. Sinceλ1, being the eigenvalue of a unitary operator, cannot be zero, w1 has to be zero, which means that (12) simplifies to
(17)O|ψ1〉=∑j=2M‍wj|ψj〉,〈ψ1|O|ψ1〉=〈ψ1|∑j=2M‍wj|ψj〉=∑j=2M‍wj〈ψ1∣ψj〉=0.
The operator O orthogonalizes |ψ1〉.


### 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 operatorP will orthogonalize an eigenvector |v1〉. Let |v2〉 be the orthogonal eigenvector (〈v1|v2〉=0). Let |vp〉=P|v1〉. If 〈v1|vp〉=0, then P is a perfect orthogonalizer. If 〈v1|vp〉=1/2, then |vp〉 has equal measures of |v1〉 and |v2〉. So, a good orthogonalizer P should give 〈v1|vp〉 to be close to 0 or at least less than 1/2.A single qubit orthogonalization operator for states with real amplitudes isiσy where σy 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, iσy 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.
|
v
〉
〈
v
|
i
σ
y
|
v
〉
〈
v
|
σ
x
|
v
〉
〈
v
|
(
σ
x
-
σ
y
)
/
2
|
v
〉
0.974930.22252
0
−0.43388
−0.30680
0.974930.22252i
−0.43388
0
−0.30680
0.87838
+
0.42301
i −0.22252
−0.3909i
−0.18825
0.1433
0.87838
+
0.42301
i 0.19271-0.11126i
−0.35869i
0.24441
0.42632We 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.


## 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 prepareVa in the state with suitable unitary operations. This is not trivial.A uniform superposition of all computational basis states as the initialVa 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 Va register contains a component of the important eigenvectors. But Abrams-Lloyd algorithm will then give at least one eigenvalue λp and the corresponding eigenvector |ϕp〉. This eigenvector could be gainfully used to generate a better approximate eigenvector.If the objective is to get another eigenvalue, then the nextVa should not have a component of the eigenvector obtained earlier. An orthogonalization operator is applied to |ϕp〉 to transform it to |ϕp⊥〉 such that 〈ϕp⊥|ϕp〉 is 0. |ϕp⊥〉 is the Va for the next calculation. Since the new Va does not have a component of |ϕp〉 because of the orthogonal construction, Abrams-Lloyd algorithm on it will not repeat the earlier eigenvalue λp 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 aVa having the important eigenvectors, a simple method would be to force it to have all the eigenvectors. Again, this could be obtained from the |ϕp〉, 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 ofl qubits. If it is in a product state, a single qubit orthogonalization operator applied to any one of the l qubits will give rise to an l 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 (l=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.


## 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 Va can be operated on by H.


## 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|ψ1〉 be the current state of the qubit that we wish to orthogonalize. Our aim is to find an operator O such that 〈ψ1|O|ψ1〉=0. Assume U to be the unitary single qubit operator whose eigenvector is |ψ1〉. If the operators U and O anticommute, O will orthogonalize |ψ1〉.Theorem 1.
Given a unitary operatorU and an operator O that anticommutes with U, then O will orthogonalize the eigenvectors of U.Proof.
ConsiderU and O to be single qubit operators. Let |ψj〉 be the eigenvector of U with eigenvalue λj. The dimension of U is M. So, j will range from 1 to M:
(10)U|ψj〉=λj|ψj〉
with
(11)〈ψi∣ψj〉=δij.
LetO operating on |ψ1〉 result in a state that can in general be expanded in terms of the eigen basis states |ψj〉:
(12)O|ψ1〉=w1|ψ1〉+∑j=2M‍wj|ψj〉.
AsO and U anticommute, OU=-UO. Then,
(13)OU|ψ1〉=-UO|ψ1〉,(14)OU|ψ1〉=Oλ1|ψ1〉OU|ψ1〉=λ1O|ψ1〉OU|ψ1〉=λ1(w1|ψ1〉+∑j=2M‍wj|ψj〉),(15)-UO|ψ1〉=-U(w1|ψ1〉+∑j=2M‍wj|ψj〉)-UO|ψ1〉=-(w1λ1|ψ1〉+∑j=2M‍wjλj|ψj〉).
Equating the|ψ1〉 components of (14) and (15),
(16)w1λ1|ψ1〉=-w1λ1|ψ1〉,w1λ1=-w1λ1.
This happens only when each side is equal to zero. Sinceλ1, being the eigenvalue of a unitary operator, cannot be zero, w1 has to be zero, which means that (12) simplifies to
(17)O|ψ1〉=∑j=2M‍wj|ψj〉,〈ψ1|O|ψ1〉=〈ψ1|∑j=2M‍wj|ψj〉=∑j=2M‍wj〈ψ1∣ψj〉=0.
The operator O orthogonalizes |ψ1〉.


## 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 operatorP will orthogonalize an eigenvector |v1〉. Let |v2〉 be the orthogonal eigenvector (〈v1|v2〉=0). Let |vp〉=P|v1〉. If 〈v1|vp〉=0, then P is a perfect orthogonalizer. If 〈v1|vp〉=1/2, then |vp〉 has equal measures of |v1〉 and |v2〉. So, a good orthogonalizer P should give 〈v1|vp〉 to be close to 0 or at least less than 1/2.A single qubit orthogonalization operator for states with real amplitudes isiσy where σy 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, iσy 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.
|
v
〉
〈
v
|
i
σ
y
|
v
〉
〈
v
|
σ
x
|
v
〉
〈
v
|
(
σ
x
-
σ
y
)
/
2
|
v
〉
0.974930.22252
0
−0.43388
−0.30680
0.974930.22252i
−0.43388
0
−0.30680
0.87838
+
0.42301
i −0.22252
−0.3909i
−0.18825
0.1433
0.87838
+
0.42301
i 0.19271-0.11126i
−0.35869i
0.24441
0.42632We 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 a6×6H matrix obtained from a spin Hamiltonian for a 4-spin chain with total spin zero. The eigenvalues and eigenvectors of H can be calculated numerically, and the eigenvalues are shown in Table 2. For Abrams-Lloyd algorithm with orthogonalization, we first construct the unitary matrix U=e-iτH with τ=1. The initial approximate eigenstate Va 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×6U 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:
(18)H=[00000.50.500000.50.500000.50.500000.50.50.50.50.50.5-100.50.50.50.50-1],U=[abbbccbabbccbbabccbbbaccccccdfccccfd],
where
(19)a=(0.805372-0.0644704i),b=(-0.194629-0.0644704i),c=(0.159408-0.291795i),d=(0.221486+0.583589i),f=(-0.318816-0.257881i).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 isiσy. The index register of 5 qubits (M=32) is measured as p.
Numerical
Abrams-Lloyd
eigenvalue of
p
eigenvalue of
H
U
U
H
−2
-
0.4162
+
0.9093
i
22
-
0.3827
+
0.9239
i
−1.9635
−1
0.5403
+
0.8415
i
27
0.5556
+
0.8315
i
−0.9818
1
0.5403
-
0.8415
i
5
0.5556
-
0.8315
i
0.9818
0
1
0
1
0
0
1
0
1
0
0
1
0
1
0


### 3.2. Computation of Initial State with All Eigenvalues

The method to generate a state containing all the eigenvectors is tested on a unitary matrixU (20). The eigenvectors of U are shown in Table 3, and the eigenvalues are shown in Table 4. Both are computed numerically:
(20)U=[a0b00-b*0a*b0a00a*0-b*],
where
(21)a=(0.85355-0.35355i),b=(0.14645+0.35355i).Table 3
The eigenvectors|ϕn〉 of U in (21). t=1/2.
|
ϕ
0
〉
|
ϕ
1
〉
|
ϕ
2
〉
|
ϕ
3
〉
[
0
t
0
t
]
[
t
0
t
0
]
[
0
t
0
-
t
]
[
t
0
-
t
0
]Table 4
The eigenvalues|λn〉 of U in (21). t=1/2.
λ
0
λ
1
λ
2
λ
3
t
+
t
i
1
-
1
t
-
t
iFor this unitary matrix, we allocate an index register of 3 qubits. For theVa, 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 Va of the simulated quantum computer) as 0.70711(|0〉+|2〉). This is |ϕ1〉. Hadamard operator H, for nonorthogonalization, is then applied to Va and the Abrams-Lloyd algorithm steps are carried out stopping short of the last measurement.The simulated quantum state is seen as0.35356(|0〉(|0〉+|2〉)-|1〉(|1〉+|3〉)-|4〉(|1〉-|3〉)+|7〉(|0〉-|2〉)). This is the same state as 0.5(|0〉|ϕ1〉-|1〉|ϕ0〉-|4〉|ϕ2〉+|7〉|ϕ3〉). 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 (Table2), 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.


## 3.1. Sequential Computation of Eigenvalues

We have tested our method with a6×6H matrix obtained from a spin Hamiltonian for a 4-spin chain with total spin zero. The eigenvalues and eigenvectors of H can be calculated numerically, and the eigenvalues are shown in Table 2. For Abrams-Lloyd algorithm with orthogonalization, we first construct the unitary matrix U=e-iτH with τ=1. The initial approximate eigenstate Va 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×6U 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:
(18)H=[00000.50.500000.50.500000.50.500000.50.50.50.50.50.5-100.50.50.50.50-1],U=[abbbccbabbccbbabccbbbaccccccdfccccfd],
where
(19)a=(0.805372-0.0644704i),b=(-0.194629-0.0644704i),c=(0.159408-0.291795i),d=(0.221486+0.583589i),f=(-0.318816-0.257881i).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 isiσy. The index register of 5 qubits (M=32) is measured as p.
Numerical
Abrams-Lloyd
eigenvalue of
p
eigenvalue of
H
U
U
H
−2
-
0.4162
+
0.9093
i
22
-
0.3827
+
0.9239
i
−1.9635
−1
0.5403
+
0.8415
i
27
0.5556
+
0.8315
i
−0.9818
1
0.5403
-
0.8415
i
5
0.5556
-
0.8315
i
0.9818
0
1
0
1
0
0
1
0
1
0
0
1
0
1
0


## 3.2. Computation of Initial State with All Eigenvalues

The method to generate a state containing all the eigenvectors is tested on a unitary matrixU (20). The eigenvectors of U are shown in Table 3, and the eigenvalues are shown in Table 4. Both are computed numerically:
(20)U=[a0b00-b*0a*b0a00a*0-b*],
where
(21)a=(0.85355-0.35355i),b=(0.14645+0.35355i).Table 3
The eigenvectors|ϕn〉 of U in (21). t=1/2.
|
ϕ
0
〉
|
ϕ
1
〉
|
ϕ
2
〉
|
ϕ
3
〉
[
0
t
0
t
]
[
t
0
t
0
]
[
0
t
0
-
t
]
[
t
0
-
t
0
]Table 4
The eigenvalues|λn〉 of U in (21). t=1/2.
λ
0
λ
1
λ
2
λ
3
t
+
t
i
1
-
1
t
-
t
iFor this unitary matrix, we allocate an index register of 3 qubits. For theVa, 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 Va of the simulated quantum computer) as 0.70711(|0〉+|2〉). This is |ϕ1〉. Hadamard operator H, for nonorthogonalization, is then applied to Va and the Abrams-Lloyd algorithm steps are carried out stopping short of the last measurement.The simulated quantum state is seen as0.35356(|0〉(|0〉+|2〉)-|1〉(|1〉+|3〉)-|4〉(|1〉-|3〉)+|7〉(|0〉-|2〉)). This is the same state as 0.5(|0〉|ϕ1〉-|1〉|ϕ0〉-|4〉|ϕ2〉+|7〉|ϕ3〉). 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 (Table2), 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.



---

*Source: 235624-2013-09-11.xml*