Qiskit官方文档选译之量子傅里叶变换(Quantum Fourier Transform, QFT)

翻译自页面：https://learn.qiskit.org/course/ch-algorithms/quantum-fourier-transform

量子傅里叶变换(Quantum Fourier Transform, QFT)

在这部分教程中，我们会介绍量子傅里叶变换(QFT)，相关电路的推导以及电路的Qiskit实现。我们会展示如何在模拟器和五量子比特设备上运行QFT。

1.介绍

傅里叶变换在经典计算中有很多版本，应用领域遍及从信号处理到数据压缩再到复杂度理论。量子傅里叶变换则是离散傅里叶变换的量子实现，它基于对波函数振幅的变换。它参与构成了很多量子算法，其中最著名的有Shor分解因子算法和量子相位估计。

该离散傅里叶变换作用于向量$(x_0,...,x_{N-1})$并且根据如下公式将其映射成另一向量$(y_0,...,y_{N-1})$：

$$y_k=\frac{1}{\sqrt{N}}\sum _{j=0}^{N-1}{x}_j{\omega }_N^{j\cdot k},{\omega }_N^{j\cdot k}=e^{2\pi i\frac{j\cdot k}{N}}$$

相似地，量子傅里叶变换作用于量子态$|X⟩={\sum }_{j=0}^{N-1}{x}_j|j⟩$并根据如下公式映射为量子态$|Y⟩={\sum }_{k=0}^{N-1}{y}_k|k⟩$：

$$y_k=\frac{1}{\sqrt{N}}\sum _{j=0}^{N-1}{x}_j{\omega }_N^{j\cdot k},{\omega }_N^{j\cdot k}=e^{2\pi i\frac{j\cdot k}{N}}$$

注意，只有态的振幅被变换影响。这一点还可以被表述为如下映射：

$$|j⟩\to \frac{1}{\sqrt{N}}\sum _{k=0}^{N-1}{\omega }_N^{jk}|k⟩$$

或者是幺正矩阵：

$$U_{QFT}=\frac{1}{\sqrt{N}}\sum _{k=0}^{N-1}{\omega }_N^{jk}|k⟩⟨j|$$

2.直观理解

量子傅里叶变换（QFT）在两组基矢间进行变换，分别是涉及计算的基矢组（Z）和傅里叶基矢组。哈达玛门就是单量子比特的QFT，它从Z基的$|0⟩$和$|1⟩$变换到X基的$|+⟩$和$|-⟩$。依照相同的方式，所有在计算基（computational basis）中的多量子比特态都有对应的傅里叶基。而QFT仅仅是在任意两组间变换的函数。

$|计算基下的态⟩\stackrel{QFT}{⟶}|傅里叶基下的态⟩$

$QFT|x⟩=|\tilde{x}⟩$（我们通常使用波浪(~)记号来表示傅里叶基）

2.1 在傅里叶基中计数

在计算基中，我们通过$|0⟩$和$|1⟩$态来存储二进制数值：

（译注：本例中最大到15，对应的二进制即1111，故最多用四个量子比特储存）

注意不同量子比特改变的频率：最左边的量子比特会随着每个数字增量翻转一次，靠右一个则是每两个增量翻转一次，第三个是每四个增量翻转一次，第四个则是每八次翻转一次。在傅里叶基中我们使用绕Z轴的不同旋转来储存数字：

我们想要储存的数值决定了每个量子比特绕Z轴旋转的角度。在$|\tilde{0}⟩$态时，每一个量子比特都处于$|+⟩$的状态。由上例可知，为了在四个量子比特上解码$|5⟩$态，我们将最左边的量子比特旋转$\frac{5}{2^n}=\frac{5}{16}$周（$\frac{5}{16}\times 2\pi$弧度）。而下一个量子比特则会将上一量子比特旋转的角度加倍（$\frac{10}{16}\times 2\pi$弧度），依此类推。

再次强调，留意每个量子比特变化的频率。最左边的量子比特（qubit 0）在本例中频率最低，而最右侧的频率最高。

3.例1：单量子比特的量子傅里叶变换(1-qubit QFT)

考虑如下定义的QFT算符是如何作用于一个量子比特态$|\psi ⟩=\alpha |0⟩+\beta |1⟩$上的。在这种情况下，$x_0=\alpha ,x_1=\beta$ 而 $N=2$。于是有：

$$y_0=\frac{1}{\sqrt{2}}\left(\alpha exp\left(2\pi i\frac{0\times 0}{2}\right)+\beta exp\left(2\pi i\frac{1\times 0}{2}\right)\right)=\frac{1}{\sqrt{2}}(\alpha +\beta ),$$

$$y_1=\frac{1}{\sqrt{2}}\left(\alpha exp\left(2\pi i\frac{0\times 1}{2}\right)+\beta exp\left(2\pi i\frac{1\times 1}{2}\right)\right)=\frac{1}{\sqrt{2}}(\alpha -\beta )$$

于是我们得到的最终结果是如下量子态：

$$U_{QFT}|\psi ⟩=\frac{1}{\sqrt{2}}(\alpha +\beta )|0⟩+\frac{1}{\sqrt{2}}(\alpha -\beta )|1⟩$$

这一操作实际上正等价于对量子比特施加哈达玛门:

$$H=\frac{1}{\sqrt{2}}\left(\begin{array}{cc}1& 1\\ 1& -1\end{array}\right)$$

如果我们在量子态$|\psi ⟩=\alpha |0⟩+\beta |1⟩$上作用哈达玛门，我们会获得新的量子态：

$$\frac{1}{\sqrt{2}}(\alpha +\beta )|0⟩+\frac{1}{\sqrt{2}}(\alpha -\beta )|1⟩\equiv \tilde{\alpha }|0⟩+\tilde{\beta }|1⟩$$

注意哈达玛门在$N=2$时是如何对量子态的振幅进行离散傅里叶变换的。

4.量子傅里叶变换

所以对更大的$N$来说量子傅里叶变换是什么样子的呢？让我们在$N=2^n$的情况下推导出一个变换，令$QF{T}_N$作用于量子态$|x⟩=|x_1...x_n⟩$，其中$x_1$是最左侧的比特。此处数学是为那些需要有用信息以进一步理解的人的，如果你觉得读起来很吃力，无须担心。只要你理解了第二节的直观内容，你就可以直接继续读下一节的内容。

$$\begin{array}{rl}QF{T}_N|x⟩& =\frac{1}{\sqrt{N}}\sum _{y=0}^{N-1}{\omega }_N^{x\cdot y}|y⟩\\ & =\frac{1}{\sqrt{N}}\sum _{y=0}^{N-1}{e}^{2\pi i\frac{x\cdot y}{2^n}}|y⟩因为{\omega }_N^{x\cdot y}=e^{2\pi i\frac{x\cdot y}{N}}且N=2^n\\ & =\frac{1}{\sqrt{N}}\sum _{y=0}^{N-1}{e}^{2\pi ix\cdot \left({\sum }_{k=1}^n{y}_k/2^k\right)}|y_1...y_n⟩重写成小数二进制记号y=y_1...y_n,y/2^n=\sum _{k=1}^{n}2/2^k\\ & =\frac{1}{\sqrt{N}}\sum _{y=0}^{N-1}\prod _{k=1}^n{e}^{2\pi ix\cdot y_k/2^k}|y_1...y_n⟩在将指数上的加和变为若干指数相乘的形式之后\\ & =\frac{1}{\sqrt{N}}\underset{k=1}{\overset{n}{⨂}}\left(e^{2\pi ix\cdot 0/2^k}|0⟩+e^{2\pi ix\cdot 1/2^k}|1⟩\right)在将加和与乘积重排并展开\sum _{y=0}^{N-1}=\sum _{y1=0}^1\sum _{y2=0}^1...\sum _{yn=0}^1之后\end{array}$$

这是我们在直观理解一节看到过的数学描述动画：

5.QFT的实现电路

QFT的实现电路会用到两种门。第一个门是你已经知道的单比特哈达玛门。从上面例一中的讨论，你已经知道了哈达玛门在单量子比特态$|x_k⟩$的作用效果是

$$H|x_k⟩=\frac{1}{\sqrt{2}}\left(|0⟩+exp\left(\frac{2\pi i}{2}{x}_k\right)|1⟩\right)$$

第二个门是一个双量子比特受控旋转门$CRO{T}_k$，给定如下块对角形式：

$$CRO{T}_k=\left(\begin{array}{cc}I& 0\\ 0& URO{T}_k\end{array}\right)$$

其中,

$$URO{T}_k=\left(\begin{array}{cc}1& 0\\ 0& exp(\frac{2\pi i}{2^k})\end{array}\right)$$

$CRO{T}_k$在前为控制位，后为目标位的双量子比特$|x_l{x}_j⟩$上的作用由下给出：

$$CRO{T}_k|0x_j⟩=|0x_j⟩以及CRO{T}_k|1x_j⟩=exp(\frac{2\pi i}{2^k})|1x_j⟩$$

给定这两种门，实现n元量子傅里叶变换的电路如下所示：

该电路通过下述的方式进行。我们从n元量子比特态$|x_1{x}_2...x_n⟩$的输入开始。

1.将哈达玛门施加于第一个量子比特后，量子态从输入态变换到

$$H|x_1{x}_2...x_n⟩=\frac{1}{\sqrt{2}}\left[|0⟩+exp(\frac{2\pi i}{2}{x}_1)|1⟩\right]\otimes |x_2{x}_3...x_n⟩$$

2.将$URO{T}_2$门以第二个量子比特为控制位并施加于第一个量子比特后，量子态被变换为

$$\frac{1}{\sqrt{2}}\left[|0⟩+exp(\frac{2\pi i}{2^2}{x}_2+\frac{2\pi i}{2}{x}_1)|1⟩\right]\otimes |x_2{x}_3...x_n⟩$$

3.在以第n个量子比特为控制位将最后一个$URO{T}_n$门施加于第一个量子比特后，量子态就变成了

$$\frac{1}{\sqrt{2}}\left[|0⟩+exp(\frac{2\pi i}{2^n}{x}_n+\frac{2\pi i}{2^{n-1}}{x}_{n-1}+...+\frac{2\pi i}{2^2}{x}_2+\frac{2\pi i}{2}{x}_1)|1⟩\right]\otimes |x_2{x}_3...x_n⟩$$

注意到$x=2^{n-1}{x}_1+2^{n-2}{x}_2+...+2^1{x}_{n-1}+2^0{x}_n$，我们可以将上述量子态写为

$$\frac{1}{\sqrt{2}}\left[|0⟩+exp(\frac{2\pi i}{2^n}x)|1⟩\right]\otimes |x_2{x}_3...x_n⟩$$

4.在对第二到第n个量子比特施加相似门序列后，我们发现最终量子态是：

$$\frac{1}{\sqrt{2}}\left[|0⟩+exp(\frac{2\pi i}{2^n}x)|1⟩\right]\otimes \frac{1}{\sqrt{2}}\left[|0⟩+exp(\frac{2\pi i}{2^{n-1}}x)|1⟩\right]\otimes \dots \otimes \frac{1}{\sqrt{2}}\left[|0⟩+exp(\frac{2\pi i}{2^1}x)|1⟩\right]$$

这正是我们推导出的将输入态进行量子傅里叶变换后的量子态，值得注意的是量子比特的顺序在输出态中被反转了。

6.例二：三元量子傅里叶变换

创建实现$|y_3{y}_2{y}_1⟩=QF{T}_8|x_3{x}_2{x}_1⟩$的步骤如下：

1.对$|x_1⟩$施加哈达玛门：

$$|{\psi }_1⟩=|x_3⟩\otimes |x_2⟩\otimes \frac{1}{\sqrt{2}}\left[|0⟩+exp(\frac{2\pi i}{2}{x}_1)|1⟩\right]$$

2.根据$|x_2⟩$在$|x_1⟩$上施加一个$URO{T}_2$门

$$|{\psi }_2⟩=|x_3⟩\otimes |x_2⟩\otimes \frac{1}{\sqrt{2}}\left[|0⟩+exp(\frac{2\pi i}{2^2}{x}_2+\frac{2\pi i}{2}{x}_1)|1⟩\right]$$

3.根据$|x_3⟩$在$|x_1⟩$上施加一个$URO{T}_3$门

$$|{\psi }_3⟩=|x_3⟩\otimes |x_2⟩\otimes \frac{1}{\sqrt{2}}\left[|0⟩+exp(\frac{2\pi i}{2^3}{x}_3+\frac{2\pi i}{2^2}{x}_2+\frac{2\pi i}{2}{x}_1)|1⟩\right]$$

4.对$|x_2⟩$施加一个哈达玛门

$$|{\psi }_4⟩=|x_3⟩\otimes \frac{1}{\sqrt{2}}\left[|0⟩+exp(\frac{2\pi i}{2}{x}_2)|1⟩\right]\otimes \frac{1}{\sqrt{2}}\left[|0⟩+exp(\frac{2\pi i}{2^3}{x}_3+\frac{2\pi i}{2^2}{x}_2+\frac{2\pi i}{2}{x}_1)|1⟩\right]$$

5.根据$|x_3⟩$在$|x_2⟩$上施加一个$URO{T}_2$门

$$|{\psi }_5⟩=|x_3⟩\otimes \frac{1}{\sqrt{2}}\left[|0⟩+exp(\frac{2\pi i}{2^2}{x}_3+\frac{2\pi i}{2}{x}_2)|1⟩\right]\otimes \frac{1}{\sqrt{2}}\left[|0⟩+exp(\frac{2\pi i}{2^3}{x}_3+\frac{2\pi i}{2^2}{x}_2+\frac{2\pi i}{2}{x}_1)|1⟩\right]$$

6.对$|3⟩$施加哈达玛门

$$|{\psi }_6⟩=\frac{1}{\sqrt{2}}\left[|0⟩+exp(\frac{2\pi i}{2}{x}_3)|1⟩\right]\otimes \frac{1}{\sqrt{2}}\left[|0⟩+exp(\frac{2\pi i}{2^2}{x}_3+\frac{2\pi i}{2}{x}_2)|1⟩\right]\otimes \frac{1}{\sqrt{2}}\left[|0⟩+exp(\frac{2\pi i}{2^3}{x}_3+\frac{2\pi i}{2^2}{x}_2+\frac{2\pi i}{2}{x}_1)|1⟩\right]$$

7.务必记住输出态的顺序反转才符合QFT的期望。因此，我们必须反转量子比特的顺序（本例中交换$y_1$和$y_3$）。

7.关于QFT电路的形式的一些注意事项

上面的示例演示了一个非常有用的 QFT 形式，用于$N=2^n$。请注意，只有最后一个量子比特依赖于所有其他输入量子比特的值，而每下一个的量子比特所依赖的输入量子比特越来越少。这在QFT的物理实现中变得很重要，其中最近邻耦合比量子比特之间的远距离耦合更容易实现。

此外，随着QFT电路变大，越来越多的时间花在进行越来越轻微的旋转上。事实证明，我们可以忽略低于某个阈值的旋转，仍然可以获得不错的结果，这被称为近似QFT。这在物理实现中也很重要，因为减少操作次数可以大大减少退相干和潜在的门错误。

8.Qiskit实现

在Qiskit中，上述$CROT$门的实现是一个受控相位旋转门。该门在OpenQASM中被定义为

$$CP(\theta )=\left(\begin{array}{cccc}1& 0& 0& 0\\ 0& 1& 0& 0\\ 0& 0& 1& 0\\ 0& 0& 0& e^{i\theta }\end{array}\right)$$

故而，从上述$CRO{T}_k$门到$CP$门的映射关系可由下面等式给出

$$\theta =2\pi /2^k=\pi /2^{k-1}$$

8.1 三量子比特的例子

%matplotlib inline
import numpy as np
from numpy import pi
# importing Qiskit
from qiskit import QuantumCircuit, transpile, Aer, IBMQ
from qiskit.providers.ibmq import least_busy
from qiskit.tools.monitor import job_monitor
from qiskit.visualization import plot_histogram, plot_bloch_multivector

在推广至n量子比特之前，研究三量子比特效果代码是非常有用的。首先，我们必须定义我们的量子电路：

qc = QuantumCircuit(3)

注意：记住Qiskit中最右侧的比特有最小的索引（0），所以电路会根据对称轴被反射成和第五节的图像近似的电路。首先，我们对第三个量子比特（qubit 2）施加哈达玛门：

qc.h(2)
qc.draw()

接着，如果第二个量子比特（qubit 1）在状态$|1⟩$时，我们想再转额外的四分之一周：

qc.cp(pi/2, 1, 2) # 从qubit 1到 qubit 2的CROT
qc.draw()

然后是八分之一周如果最小索引的量子比特（qubit 0）在状态$|1⟩$:

qc.cp(pi/4, 0, 2) # 从qubit 2到qubit 0的CROT
qc.draw()

在处理好该量子比特后，我们可以忽略它并重复这一过程，对qubit 0和qubit 1施加同样的逻辑：

qc.h(1)
qc.cp(pi/2, 0, 1) # CROT from qubit 0 to qubit 1
qc.h(0)
qc.draw()

最后我们必须交换qubit 0和qubit 2来完成QFT:

qc.swap(0,2)
qc.draw()

8.2 普适QFT函数

现在，我们将在Qiskit中为QFT创建一个通用电路。创建像这样的大型通用电路是Qiskit真正的亮点。
构建一个实现量子傅里叶变换的电路，将量子比特倒过来，然后交换它们更容易;我们将从创建正确旋转量子比特的函数开始。让我们像3个量子比特的例子一样开始，通过正确旋转最有效的量子比特(具有最高索引的量子比特):

def qft_rotations(circuit, n):
    if n == 0: # 如果电路为空则退出
        return circuit
    n -= 1 # 索引从0开始
    circuit.h(n) # 对最高索引的量子比特施加哈达玛门
    for qubit in range(n):
        # 对每个较小索引的量子比特，我们需要
        # 进行一个小角度的旋转: 
        circuit.cp(pi/2**(n-qubit), qubit, n)

让我们看看它长什么样子：

qc = QuantumCircuit(4)
qft_rotations(qc,4)
qc.draw()

我们可以使用下面的控件来观察这个电路是如何在我们的电路中根据量子比特数目而增长的：

from qiskit_textbook.widgets import scalable_circuit
scalable_circuit(qft_rotations)

太棒了!这是我们QFT的第一部分。现在我们已经正确旋转了最高索引的量子比特，我们需要正确旋转第二个最高索引的量子比特。然后我们必须处理第三个最高索引的，以此类推。但是为什么要写更多的代码呢?当我们到达qft_rotations()函数的末尾时，我们可以使用相同的代码对下一个n-1个量子比特重复上述过程:

def qft_rotations(circuit, n):
    """在前n个量子比特中实现量子傅里叶变换 (没有交换)"""
    if n == 0:
        return circuit
    n -= 1
    circuit.h(n)
    for qubit in range(n):
        circuit.cp(pi/2**(n-qubit), qubit, n)
    # 在我们函数的最后，我们再次针对接下来的量子比特调用同样的函数
    # （在前面的过程中我们已经减小了n的数值）
    qft_rotations(circuit, n)

# 让我们看看它长什么样子：
qc = QuantumCircuit(4)
qft_rotations(qc,4)
qc.draw()

这很容易!函数直接或间接调用自身的过程称为递归。它可以极大地简化代码。使用下面的小控件，我们可以再次看到它是如何缩放的:

scalable_circuit(qft_rotations)

最后，我们需要在QFT函数的末尾添加交换，以匹配QFT的定义。我们将把它合并到最终的函数qft()中:

def swap_registers(circuit, n):
    for qubit in range(n//2):
        circuit.swap(qubit, n-qubit-1)
    return circuit

def qft(circuit, n):
    """对电路中前n个量子比特施加QFT"""
    qft_rotations(circuit, n)
    swap_registers(circuit, n)
    return circuit

# 让我们看看它长什么样子：
qc = QuantumCircuit(4)
qft(qc,4)
qc.draw()

这是量子傅里叶变换的广义电路。使用下面的小控件，我们可以再次看到它是如何缩放的:

scalable_circuit(qft)

我们现在要演示这个电路的正确工作。要做到这一点，我们必须首先在计算基中编码一个数字。我们可以看到二进制数字5是101:

bin(5)

(0b提醒我们这是个二进制数)让我们将其编码到量子比特中:

# 创建电路
qc = QuantumCircuit(3)

# 加密量子态 5
qc.x(0)
qc.x(2)
qc.draw()

让我们用aer模拟器来检查量子比特的状态:

sim = Aer.get_backend("aer_simulator")
qc_init = qc.copy()
qc_init.save_statevector()
statevector = sim.run(qc_init).result().get_statevector()
plot_bloch_multivector(statevector)

最后，让我们使用我们的QFT函数并查看我们的量子比特的最终状态：

qft(qc,3)
qc.draw()

qc.save_statevector()
statevector = sim.run(qc).result().get_statevector()
plot_bloch_multivector(statevector)

我们可以看出QFT函数很好的工作了。比起量子态$|\tilde{0}⟩=|+++⟩$，Qubit 0被旋转了$\frac{5}{8}$周，qubit 1则是$\frac{10}{8}$周，qubit 2则是$\frac{20}{8}$周

8.3 在真机上运行QFT

如果我们尝试在一个真实的设备上运行8.2节末尾的电路，结果将是完全随机的，因为所有量子比特都是$|0⟩$和$|1⟩$的相等叠加。如果我们想要演示和研究QFT在真实硬件上的工作，我们可以创建状态$|\tilde{5}⟩$。参见8.2节的末尾，反向运行QFT，并验证输出是预期的状态$|5⟩$。

首先，让我们使用Qiskit轻松反转我们的QFT操作:

def inverse_qft(circuit, n):
    """Does the inverse QFT on the first n qubits in circuit"""
    # First we create a QFT circuit of the correct size:
    qft_circ = qft(QuantumCircuit(n), n)
    # Then we take the inverse of this circuit
    invqft_circ = qft_circ.inverse()
    # And add it to the first n qubits in our existing circuit
    circuit.append(invqft_circ, circuit.qubits[:n])
    return circuit.decompose() # .decompose() allows us to see the individual gates

现在让我们把我们的量子比特输入成$|\tilde{5}⟩$：

nqubits = 3
number = 5
qc = QuantumCircuit(nqubits)
for qubit in range(nqubits):
    qc.h(qubit)
qc.p(number*pi/4,0)
qc.p(number*pi/2,1)
qc.p(number*pi,2)

qc.draw()

然后我们可以看出这确实是傅里叶态$|\tilde{5}⟩$中的结果：

qc_init = qc.copy()
qc_init.save_statevector()
sim = Aer.get_backend("aer_simulator")
statevector = sim.run(qc_init).result().get_statevector()
plot_bloch_multivector(statevector)

最后，让我们施加我们的逆QFT运算：

qc = inverse_qft(qc, nqubits)
qc.measure_all()
qc.draw()

# 导入我们已保存的IBMQ账号并获得最空闲的后端设备，其应具有少于或等于n的量子比特数
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= nqubits 
                                       and not x.configuration().simulator 
                                       and x.status().operational==True))
print("least busy backend: ", backend)

shots = 2048
transpiled_qc = transpile(qc, backend, optimization_level=3)
job = backend.run(transpiled_qc, shots=shots)
job_monitor(job)

counts = job.result().get_counts()
plot_histogram(counts)

我们（抱有希望地）看到最可能的结果是101.

欢迎加入Qiskit交流群：1064371332