HHL算法的QISKit实现

本实现基于IBM QISKit 0.7.0版本，python 3.7版本。

HHL Experiment (Quantum Algorithm for linear systems of equations)

This experiment is implemented based on IBM QISKit version 0.7.0. It is a quantum implementation of finding $x$ satisfying $Ax=b$, and only for the case when $A$ is a 2 by 2 matrx, while $b$ is a 2 by 1 vector.

The whole process can be divided into several steps:

1. Quantum phase estimation
2. Controlled rotation
3. Inverse quantum phase estimation

The quantum circuit for this experiment is (from reference3):

The first qubit $|x_1⟩$ is the ancilla register for controlled rotation. The second and third qubit $|x_2{x}_3⟩$ (the register C) will save the superposition of the eigenvalues of A, after the quantum phase estimation. The forth qubit $|x_4⟩$ is used to save $|b⟩$, and after the whole process of HHL, it will save the approximate value of $x$.

# Import packages
%matplotlib inline
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute
from qiskit import BasicAer
from math import pi
from qiskit.tools.visualization import plot_histogram

import warnings  # Ignore the warning message
warnings.filterwarnings('ignore')

The known $A$ and $b$ are set like this in this experiment:

$A=\frac{1}{2}\left(\begin{array}{cc}3& 1\\ 1& 3\end{array}\right)$ and $b=\left(\begin{array}{c}{b}_1\\ b_2\end{array}\right)$.

$b$ can be encoded in a quantum state that $|b⟩=b_1|0⟩+b_2|1⟩$, which fulfills $b_1^2+b_2^2=1$.

And the eigenvalues of A are ${\lambda }_1=1$ and ${\lambda }_2=2$ with corresponding eigenvectors $|u_1⟩$ and $|u_2⟩$. ${\lambda }_1$ and ${\lambda }_2$ can be encoded by $|x_2{x}_3⟩=|01⟩$ and $|x_2{x}_3⟩=|10⟩$ respectively. (Actually all 2 by 2 matrics with eigenvalues 1 and 2 can be realized by this circuit.)

Step 1. Apply quantum phase estimation

This step is to determine the eigenvalues of A.

1.1 Initialization

Here we use $|b⟩=|1⟩$ as an example, and the initial value for $|x_1{x}_2{x}_3{x}_4⟩$ is $|0001⟩$.

1.2 Create superposition

Apply Hadamard gate to the ancilla register and the register C.

1.3 Apply controlled-U gate

The controlled-U gates in this process can be implemented by phase shift gates, with phases $exp(iA{t}_0/4)$ and $exp(iA{t}_0/2)$ (here we let $t_0=2\pi$):

The picture above is from https://www.youtube.com/watch?v=v1AUILJz3RU.

1.4 Inverse Fourier transform

Apply inverse Fourier transform to the register C.

## 1.1 Initialization
n = 4 # Set the number of qubits in the register
q = QuantumRegister(n, 'q') # Create a Quantum Register with n qubits.
register = QuantumCircuit(q) # Create a Quantum Circuit acting on the q register
register.x(q[3]) 

## 1.2 Create superposition
register.h(q[1]) 
register.h(q[2])

## 1.3 Apply controlled-U gate
register.u1(pi/2, q[2])
register.u1(pi, q[1])
register.cx(q[2], q[3]) #additional, still need to figure out why

## 1.4 Inverse quantum Fourier transform
register.swap(q[1], q[2])
register.h(q[2]) #iQFT
register.cu1(-pi/2, q[1], q[2])
register.h(q[1])

After the phase estimation the state of $|x_1{x}_2{x}_3⟩$ becomes ${\beta }_1|01⟩|u_1⟩+{\beta }_2|10⟩|u_2⟩$, where ${\beta }_1$ and ${\beta }_2$ are expansion coefficients of $|b⟩$ in $A$'s eigenbasis.

Step 2. Controlled rotation

You can find more mathematical derivations about this step here.

2.1 Get ${\lambda }_1^{-1}$ and ${\lambda }_2^{-1}$ using a SWAP gate

After the SWAP gate, the state of $|x_1{x}_2{x}_3⟩$ becomes ${\beta }_1|10⟩|u_1⟩+{\beta }_2|01⟩|u_2⟩$. We can now interpret $|x_2{x}_3⟩=|10⟩$ as the state encoding the inverted eigenvalue $2{\lambda }_1^{-1}=2$ and $|x_2{x}_3⟩=|01⟩$ as that encoding $2{\lambda }_2^{-1}=1$.

Here in our implementation, the matix A have eignvalues 1 and 2. I also give an example of getting ${\lambda }_1^{-1}$ and ${\lambda }_2^{-1}$ when the eigenvalues are 1 and 3. Thus we use $A=\left(\begin{array}{cc}2& 1\\ 1& 2\end{array}\right)$ as the input matrix instead. In this example, we need to use a X gate on $|x_2⟩$ to instead the SWAP gate between $|x_2⟩$ and $|x_3⟩$.

2.2 Apply rotation $R_y$

This process is to save ${\lambda }_j^{-1}$ into the amplitudes of the ancilla register.

$R_y(\theta )=\left(\begin{array}{cc}cos(\frac{\theta }{2})& -sin(\frac{\theta }{2})\\ sin(\frac{\theta }{2})& cos(\frac{\theta }{2})\end{array}\right)$, and the $r$ in the $R_y$ gate is a parameter that ranges between $lo{g}_{2}2\pi$ and $lo{g}_{2}2\pi /\omega$ with $\omega$ being the minimum angle that can be resolved. Here we choose r=4, because when x=4, the system has a good performance on both the fidelity and the probability, as is shown in the picture below (from reference 3):

A more detailed explanation for $r$ can be found in reference 3.

## 2.1 SWAP
# register.swap(q[1], q[2])  # for eigenvalues 1 and 2
register.x(q[1])  # for eigen values 1 and 3

## 2.2 rotation R_y
register.cu3(pi/8, 0, 0, q[1], q[0])
register.cu3(pi/16, 0, 0, q[2], q[0]) 

Step 3. Uncompute

This process is to do the inverse of all operations before $R_y$, which is denoted by $U^{†}$ in the circuit.

# register.swap(q[1], q[2])  # for eigenvalues 1 and 2
register.x(q[1])  # for eigenvalues 1 and 3
register.h(q[1]) #iQFT
register.cu1(pi/2, q[1], q[2])
register.h(q[2])
register.swap(q[1], q[2])

register.cx(q[2], q[3]) #additional, still need to figure out why
register.u1(-pi, q[1])
register.u1(-pi/2, q[2])

register.h(q[2]) 
register.h(q[1]) 

Step 4. Measurement

4.1 Quantum circuit

# Create a Classical Register with n bits.
c = ClassicalRegister(n, 'c')
# Create a Quantum Circuit
measure = QuantumCircuit(q, c)
measure.barrier(q)
# map the quantum measurement to the classical bits
measure.measure(q,c)

# The Qiskit circuit object supports composition using
# the addition operator.
qc = register + measure

#drawing the circuit
qc.draw(output="mpl")

4.2 Run on local simulator

The final state for the $|x_1{x}_2{x}_3{x}_4⟩$ should be $a|0000⟩+b|0001⟩+c|1000⟩+d|1001⟩$ (The $|x_2{x}_3⟩$ is always $|00⟩$). Because we can only get the $|x⟩$ when the ancilla qubit, $|x_1⟩=|1⟩$, so we only care about the last two possible states of $|x_1{x}_2{x}_3{x}_4⟩$.

Note that the rightmost qubit in the result is q0 ($|x_1⟩$), the leftmost is q3 ($|x_4⟩$). Thus in this implementation the two states that we need to pay attention to is ‘0001’ and ‘1001’. The ratio of these two probabilities, which is $|c/d{|}^2$, is close to $|x_1/x_2{|}^2$ ($x=(x_1{x}_2{)}^T$).

# Use Aer's qasm_simulator
backend_sim = BasicAer.get_backend('qasm_simulator')

# Execute the circuit on the qasm simulator.
# We've set the number of repeats of the circuit to be 1024, which is the default.
job_sim = execute(qc, backend_sim, shots=8192)

# Grab the results from the job.
result_sim = job_sim.result()

counts = result_sim.get_counts(qc)
print(counts)
x1_square = counts['0001']
x2_square = counts['1001']
p = x1_square/x2_square
print('probability of state 0001:', x1_square)
print('probability of state 1001:', x2_square)
print('the ratio of two probabilities', p)
plot_histogram(result_sim.get_counts())

{'0000': 3, '0001': 85, '1000': 7809, '1001': 295}
probability of state 0001: 85
probability of state 1001: 295
the ratio of two probabilities 0.288135593220339

Reference:

1. Aram W Harrow, Avinatan Hassidim, and Seth Lloyd. Quantum algorithm for linear systems ofequations. Physical review letters, 103(15):150502, 2009.
2. Yudong Cao, Anmer Daskin, Steven Frankel, and Sabre Kais. Quantum circuit design forsolving linear systems of equations.Molecular Physics, 110(15-16):1675–1680, 2012.
3. Yudong Cao, Anmer Daskin, Steven Frankel, and Sabre Kais. Quantum circuits for solvinglinear systems of equations.arXiv preprint arXiv:1110.2232v3, 2013.
4. Jian Pan, Yudong Cao, Xiwei Yao, Zhaokai Li, Chenyong Ju, Hongwei Chen, Xinhua Peng,Sabre Kais, and Jiangfeng Du. Experimental realization of quantum algorithm for solving linearsystems of equations.Physical Review A, 89(2):022313, 2014.
5. X-D Cai, Christian Weedbrook, Z-E Su, M-C Chen, Mile Gu, M-J Zhu, Li Li, Nai-Le Liu,Chao-Yang Lu, and Jian-Wei Pan. Experimental quantum computing to solve systems of linearequations.Physical review letters, 110(23):230501, 2013.
6. The implementation of HHL on QISKit