量子机器学习教程（二）

原文：Quantum Machine Learning

协议：CC BY-NC-SA 4.0

四、量子信息科学

云彩飘进了我的生活，不再带来雨水或风暴，而是给我落日的天空增添色彩。

—罗宾德拉纳特·泰戈尔

量子信息涉及利用量子力学的特性来处理和传输信息。量子信息是指可以物理存储在量子系统中的数据。量子信息理论是研究这种信息如何被编码、测量和操纵的。量子计算是量子信息的一个子领域。它经常被用作量子信息理论的同义词，量子信息理论研究使用量子系统执行计算的协议和算法。

引用加州理工学院量子计算大师约翰·普雷斯基尔教授的话，“信息是以物理系统的状态编码的东西。”传统上，计算是在物理上可实现的设备上进行的。因此，一个不可回避的事实是，对计算信息过程的研究应该与对潜在的物理过程的研究内在地联系起来。

Note

本章重点介绍量子信息科学的基础知识，如量子并行性、Deutsch 算法、Qiskit 和 Google 的 Cirq 实践练习以及相关理论。本章以介绍量子计算系统作为我们处理的各种平台的先驱而结束。这应该为你在本书的未来章节中更深入地钻研量子算法和机器学习的应用做好准备。

物理学的发展与信息的使用和操作有显著的关系。1961 年提出的兰道尔原理指出，信息的擦除本质上是一个耗散过程。例如，我们可以考虑一个假设的“盒子里的原子”的情况，其中一个原子被放置在一个中间有水平隔板的充满气体的盒子里。如果原子被移动到分区的下半部分，它将被擦除，不管它是从顶部还是底部开始。分开上下两半的隔板突然移开，活塞压缩单原子气体，直到原子被限制在下半部分。压缩气体的行为导致气体熵的减少。单原子理想气体的熵 S 的变化给出如下【28】。

)

其中 N 为原子数， k 为玻尔兹曼常数， V _f 为压缩后的最终体积， V _i 为初始体积。随着熵的变化，从“盒子”到环境的热量也随之变化。如果我们认为系统是等温的(即温度保持恒定在 T 的系统)，则在盒子上做功)。如果用来擦除信息，就必须付出代价，也许是电费或煤气费。

根据朗道原理，如果电池供应有限，那么计算时间就应该有一个理论极限。然而，随着我们对信息物理学的理解不断发展，查尔斯·贝内特提出了这个理论。他在 1973 年指出，计算可以只用可逆的步骤来完成。原则上不需要耗散，不需要电力支出；于是，可逆计算。

根据理论，不需要付费来执行计算。然而，在实践中，今天使用的“不可逆”计算机消耗了大量的能量，数量级高于估计值)。随着计算组件不断变得越来越小，击败兰道尔原理变得越来越重要，这样组件就不会在产生的热量中腐蚀或熔化；因此，可逆计算可能是留给工程的唯一选择。因此，量子信息演变为今天物理学和计算机科学的接口。

量子信息

经典信息论源于“信息是物理的”这一基本原则，本能地，它对我们思考信息的物理解释具有指导意义。在很大程度上征服了经典信息的大部分细节之后，我们必须考虑量子力学的法则从根本上支配着宇宙。

量子物理学是真正的随机性所在，与其经典对应物相反，经典对应物很大程度上是确定性的。在量子理论中，不可交换的可观察量不能同时具有由海森堡测不准原理描述的精确定义的值(第一章)。此外，如果对变量 x 进行测量，那么如果 x 和 y 不互换，则该测量行为会影响可观察变量 y 的后续测量结果。这意味着获取关于物理系统的信息的行为扰乱了物理系统；这不是经典物理学所受的限制。

信息由物质和能量的配置来表示；因此，信息存储、传输和处理的方式是由物理系统的法则决定的。在人类可以理解的尺度上，相关的物理定律是量子力学的定律。因此，量子信息是研究量子理论如何影响我们概念化和处理信息的能力。图 4-1 是量子信息处理的图示。

这导致了对如何理解和管理复杂的量子系统的信息携带特性的研究。对量子领域信息科学的日益了解为传统“经典”信息理论不可能实现的新应用打开了大门，例如完美安全通信、量子系统的高效模拟和超快量子计算机。近年来，在将量子信息带入现实世界方面，人们的兴趣和进展出现了爆炸式增长。它还提供了对物理、计算和信息的基本性质的见解。在实验室之外，第一批商用量子设备已经出现在市场上。

图 4-1

量子信息处理的概念

在物理系统中制造扰动以获取信息之间的权衡是由于量子系统的随机性。从一个量子系统中获取信息也会引起一个与不可克隆定理 *，*相关的扰动，该定理指出量子信息不能被完美保真地复制。如果有可能完美地复制量子信息，这将使我们能够在不干扰原件的情况下测量副本的可观测属性，从而使我们能够绕过“测量时被干扰”的属性。但是，不可克隆定理禁止这种行为。正如我们所知，没有什么能完美地阻止经典信息的复制。几十年来，当任何人试图备份数据库或硬盘，甚至试图复制粘贴简单的文本时，这一特性都帮助了计算用户及其更大的生态系统。

量子电路和布洛赫球

量子计算电路是量子逻辑门的网络，其中每个门对一个或多个量子位执行某种特定的酉变换。与经典计算类似，量子电路是使用不同种类的运算选项构建的。这一部分详细阐述了第一章中提到的量子门的基础知识。它使用量子电路进行了一些实验，作为使用 Python 中的量子计算库进行编码的热身。这种电路是用量子门构建的，量子门一次对一个或两个量子位起酉算子的作用。这些电路可以使用本章中称为qCircuitCirq.ipynb的 Python 笔记本来运行。这段代码运行在谷歌 Cirq 量子模拟器上，包括一个量子隐形传态实验。

量子态空间由称为希尔伯特空间的复向量空间构成(在第一章中讨论)。在量子信息科学中，总是假设希尔伯特空间)是有限维的。由于)是有限维的，可以选择一个基将这个基中的向量表示为有限列向量，用有限矩阵表示算子。量子计算感兴趣的希尔伯特空间通常具有维度 d = 2 ^{* n *} ，对于某些正整数 n 。一个量子位状态可以被表示为 u，而没有任何一般性损失，如下所示。

)

(4.1)

其中，通常，kets ∣0⟩和∣1⟩是正交基，0 ≤ θ ≤ π 和 0 ≤ ϕ ≤ 2 π 和 i 表示状态向量的虚部。这通常被称为计算基础，而不具体说明该基础的物理实现。在量子信息科学中，计算可视化有助于将这种状态映射到布洛赫球，如图 4-2 所示。

图 4-2

布洛赫球

布洛赫球是一个抽象的三维表示，用球上的一个点来表示量子位的状态。就布洛赫球而言，基态∣0⟩和∣1⟩分别是北极和南极。X 轴与球面相交的对跖点对应于以下标准正交态

)

(4.2)

)

(4.3)

方程式 4.2 和 4.3 类似于方程式 1。19 和 1。20 。换句话说，参照第一章， H ∣0⟩ = ∣ + ⟩，h∣1⟩=∣⟩.这些状态被称为哈达玛基，因为它们可以通过应用称为哈达玛变换、 H 的 2 × 2 酉矩阵从计算基中获得。

)

(4.4)

哈达玛变换与泡利矩阵有关。参考等式 1。13 ，其给出了泡利矩阵的数学表示，我们看到 Y 轴与球体表面相交的对跖点对应于以下正交正态。

)

(4.5)

)

(4.6)

图 4-3 显示了布洛赫球上的一些量子位状态。

图 4-3

具有单量子位状态的布洛赫球(来源[31])

布洛赫球面上的叠加

叠加在第一章中定义。由量子位构建的状态空间比由经典的二进制位表示的对应状态空间携带更多的信息，因为量子位状态是根据两个连续的实参数 θ 和 ϕ 来指定的。换句话说，经典描述只告诉我们是在北半球还是南半球，而量子位状态向量区分的是布洛赫球表面的每一点。

量子位状态通常被表示为∣0⟩和∣1⟩.基态的叠加如果对大量 N 个相同的单量子位状态进行测量，那么大约)次输出为 0，大约)次输出为 1。概率对量子世界的影响与经典世界有着显著的不同。

有可能在量子计算机上开始一个物理过程——无论是门还是退火过程——以∣0⟩为初始状态，然后让状态演化。这种状态的演变也可以通过使用哈达玛算符 H 来完成，类似于我们之前实验的 GHZ 电路。如果这是在一个经典系统上尝试，第一步，经典推理，说我们有 50%的机会在∣0⟩，50%的机会转到∣1⟩.现在假设该过程的第二步通过 Hadamard 算子再次进行进化。在这里，经典推理说，如果我们在第一步后仍在∣0⟩，有 50%的机会，我们会在第二步后留在∣0⟩；此外，如果我们碰巧在第一步后翻转到∣1⟩州，有 50%的可能性在第二步该州再次翻转，最终回到∣0⟩.因此，经典推理说，在应用h2 之后，处于状态∣0⟩的总概率由下式给出，即 50%。

)

然而，如果我们现在考虑这样一个事实，即h2 是一个恒等运算符(即等于 1)，那么我们认识到这个物理过程在 100%的时间里都将∣0⟩作为输出。这里的区别在于，量子测量产生的概率计算可以考虑干涉效应。用经典的波动行为来经典地模拟干涉是可能的，但这是量子物理已经内置于其中的固有属性。

在这个例子中暴露出的经典推理的局限性表明，我们在思考量子叠加态时应该小心。这是因为量子位状态)在∣0⟩和∣1⟩同时是而不是。它不在任何一个州。取而代之的是一种不同的物理状态，叫做∣− ⟩状态。在量子位元的某些物理实现中，阿达玛基底和计算基底一样是测量状态的好基底。如果用来测量的基被交换，那么|−⟩态就不是叠加态。对于希尔伯特空间中的任何状态，总是有测量基的选择，其中该状态是基状态之一，因此不是叠加态。因此，叠加是没有意义的，除非量子系统指出某些测量基础优于其他测量基础。

具有 Qiskit 的量子电路

2017 年 3 月，IBM 宣布发布 IBM Quantum Experience，这是一个连接到用超导材料获得的真实量子处理器的平台。有可能通过云接入使用这个量子计算平台，在量子硬件系统上执行程序。Qiskit 允许管理真实和模拟的量子电路。编程可以通过图形界面或 CLI(命令行界面)来完成。量子计算环境还通过 API(应用编程接口)提供可编程性:一组用于与设备和模拟器接口以及运行实验的类、函数和数据结构。根据他们的 API 文档[275]，Qiskit 的框架有以下主要方面。

• 奇斯基特

• Qiskit 模拟器(Aer)

• 齐斯基特实验(伊格尼丝)

• Qiskit 应用模块(Aqua)

• Qiskit IBM Quantum(提供商)

用 Qiskit 编写的程序遵循基于三个高级步骤的固定工作流。

1. 建立一个电路。

2. 执行程序。

3. 分析结果。

Qiskit 管理三个主要对象[275]来执行工作流:provider、backend,和job。provider提供了一组不同的backend来选择适合我们特定算法的。AER provider允许访问不同的模拟器，而 IBM provider允许通过 IBMQ 模块访问真实的量子位环境。

backend负责运行量子电路并返回结果。它们将一个qobj作为输入，并返回一个BaseJob对象。每个执行都由一个惟一的地址标识，可由Job对象访问，该对象找出给定时间点的执行状态(例如，如果作业正在排队、正在运行或已经失败)。Qiskit 工作流程如图 4-4 所示。

图 4-4

Qiskit 工作流

Qiskit 提供了用 Bloch 球模拟量子态空间的选项。要实现正确的可视化并在 Jupyter notebook 上正确操作，需要 Qiskit Terra 0.16 . x 版以及 Python 3.6 或更高版本。这可以在 Linux 环境中通过以下命令进行安装。

$ pip install qiskit[visualization]

如果您已经安装了 Qiskit，并在没有 Qiskit Terra 0.16.x 提供的可视化更新的情况下尝试该代码，您可能会遇到以下错误。

VisualizationError – input is not a valid N-qubit state.

如果您已经安装了 Qiskit 和较旧版本的 Terra，并且遇到了这个错误，请使用-U选项更新qiskit[visualization]。

如果您在 Windows 上有一个 Anaconda 环境，请在命令行窗口(cmd.exe)中打开一个 Anaconda 提示符，并键入以下内容。

conda install qiskit[visualization] -U

这将启动图 4-5 所示的所有相关文件的更新、下载和安装。

图 4-5

Qiskit Terra 更新并安装在 Windows 上的 Anaconda 中

一旦 Qiskit 包成功安装，我们就可以使用 Bloch 球体尝试一些量子态的可视化练习。这解释了三维布洛赫表面上的矢量的解释。我们从导入Qiskit库开始，并使用清单 4-1a 中所示的plot_bloch_vector()函数为 Jupyter 笔记本qiskitBloch.ipynb文件可视化一个样本 Bloch 球体。qiskit.__qiskit_version__显示所有 Qiskit 组件和 API 的工作版本。

## import the libraries
import numpy as np
from qiskit import *
qiskit.__qiskit_version__

from qiskit.visualization import plot_bloch_vector
%matplotlib inline
plot_bloch_vector([0,1,0], title="Bloch Sphere")

Listing 4-1aBloch Sphere Simulation in qiskitBloch.ipynb

这段代码生成版本号和我们的示例 Bloch sphere 作为输出，如图 4-6 所示。

图 4-6

样本 Bloch 球体和版本号

Note

不要混淆量子位的状态向量和它的布洛赫向量。状态向量是保存量子位可能处于的两种状态的振幅的向量。Bloch vector 是一个可视化工具，它将二维的复杂状态向量映射到真实的三维空间。布洛赫球是纯态的几何表示。提供绘制斑点球的 Qiskit 函数是 plot_bloch_vector()。值得注意的是，每个布洛赫球代表一个量子位取向(即，两个量子位由两个布洛赫球代表；三个量子位需要三个布洛赫球，依此类推)。

了解 Qiskit 如何处理门定义是很有帮助的。我们在本章前面的 Qiskit 中遇到了 GHZ 态。为此，我们首先导入所有必要的库，如清单 4-1b 所示，并尝试一个 X gate。当我们看泡利门(方程式 1 时，x 门的定义在第一章中有所涉及。13 。在这个例子中，使用了plot_bloch_multivector()函数，它接受一个量子位的状态向量，而不是 Bloch 向量。

from math import pi
from qiskit.visualization import plot_bloch_multivector
#X-gate on a |0> qubit
qc = QuantumCircuit(1)
qc.x(0)
qc.draw()

Listing 4-1bGate Programming in qiskitBloch.ipynb

清单 4-1b 给出以下电路作为输出。

这里，我们在状态)对一个量子位执行了 x 或非门操作，并将其翻转到∣1⟩.状态让我们在一个布洛赫球表示上验证 X-gate 操作的结果，如清单 4-1c 所示。

# Verify The result
backend = Aer.get_backend('statevector_simulator') # Simulate
out = execute(qc,backend).result().get_statevector() # Do the simulation, returning the statevector
plot_bloch_multivector(out) # Display the output state vector

Listing 4-1cBloch Representation of the X-operation qiskitBloch.ipynb

清单 4-1c 给出了下面的 Bloch 球表示作为输出。

输出证实了量子位的状态是预期的∣1⟩。这是绕布洛赫球的 X 轴旋转了 π 弧度。

Qiskit 库允许在电路中添加门。例如，如果我们要将 Pauli Y 和 Z gate 添加到我们之前创建的 X gate 中，我们需要清单 4-1d 中的代码片段。

qc.y(0) # Do Y-gate on qubit 0
qc.z(0) # Do Z-gate on qubit 0
qc.draw()

Listing 4-1dY and Z gate Addition to X Gate qiskitBloch.ipynb

这个代码片段给出了下面的电路作为输出。

Qiskit 仅允许测量 Z 基准。当进行测量时，并不总是要求以任何固定的计算基础(即 Z 基础)进行测量。量子位的测量可以在我们选择的任何基础上进行。例如，我们可以计算在 x 轴上测量∣+ ⟩或∣− ⟩的概率。

p(|+⟩)= |⟨+|q⟩|²，p(|−⟩)= |⟨−|q⟩|²

一旦测量完成，量子位就保证处于这两种状态之一。由于 Qiskit 只允许在 Z 基础上进行测量，因此需要我们使用 Hadamard 门创建自己的测量(参见清单 4-1e )。

# Create Hadamard gate for the X-measurement function:
def x_measurement(qc,qubit,cbit):
    """Measure 'qubit' in the X-basis, and store the result in 'cbit'"""
    qc.h(qubit)
    qc.measure(qubit, cbit)
    qc.h(qubit)
    return qc

initial_state = [0,1]
# Initialise our qubit and measure it
qc = QuantumCircuit(1,1)
qc.initialize(initial_state, 0)
x_measurement(qc, 0, 0)  # measure qubit 0 to classical bit 0
qc.draw()

Listing 4-1eHadamard qiskitBloch.ipynb

该代码片段给出了以下电路，其中 H 门和 M 门用于测量作为输出。

这些练习演示了通过将 Z 门夹在两个 H 门之间来创建 X 门是可能的。

)

计算从 Z 开始。然后 H 门将量子位切换到 X 基，之后 Z 门在 X 基中执行 NOT，最后另一个 H 门将量子位返回到 Z 基。接下来，我们使用与清单 4-1c 相同的语法在 Bloch 球体上执行验证，并获得图 4-7 中的以下输出。

图 4-7

X gate 基础转移的验证

如果 Jupyter 笔记本单元格再次运行，您可能会看到不同的结果；然而，量子位的最终状态总是∣+ ⟩或∣− ⟩.量子位在|1⟩.状态下被初始化测量的结果是，∣+ ⟩和∣− ⟩.崩溃了

Qiskit 允许在真实设备或qasm_simulator上运行的量子电路的数据可视化。为了方便起见，有一个plot_histogram(data)函数。作为一个例子，看看如何用 Qiskit 创建钟形状态。两个量子位系统的计算基可以转换成由四个贝尔态定义的标准正交基。

带 Qiskit 的贝尔州

当一个系统纠缠在一起时，各个独立的系统组成一个整体。任何测量系统的一部分——在我们的例子中是第一个粒子——的测量都是对整个系统的测量。然后系统的波函数坍缩，两个粒子都呈现确定的状态。两党制基础的一个流行例子是贝尔基础或贝尔态。两个量子位的贝尔态通常由下式给出。

)

(4.7)

)

(4.8)

)

(4.9)

)

(4.10)

∣β??⟩态被称为三重态。有三种三重态。另外两个是∣00⟩和|11⟩.∣β11⟩被称为单态。清单 4-1f 显示了一个构建铃态的量子电路，它打印铃测量计数，然后生成一个直方图。

# quantum circuit to create a Bell state
bell = QuantumCircuit(2, 2)
bell.h(0)
bell.cx(0, 1)

meas = QuantumCircuit(2, 2)
meas.measure([0,1], [0,1])

# execute the quantum circuit
backend = BasicAer.get_backend('qasm_simulator') # the device to run on
circ = bell + meas
result = execute(circ, backend, shots=1000).result()
counts  = result.get_counts(circ)
print(counts)

from qiskit.visualization import plot_histogram
plot_histogram(counts)

Listing 4-1fBell State qiskitBloch.ipynb

这将产生以下输出，作为对响铃状态的测量计数。

图 4-8 中的直方图是从qiskit.visualization.调用的plot_histogram()函数的输出

图 4-8

贝尔状态概率直方图

本节是一个热身练习，让我们深入了解 Qiskit 在接下来的章节中的操作，在接下来的章节中，我们将专注于定义更复杂的算法。

具有 Cirq 的量子电路

量子计算机在基于门的量子计算机中，基于对量子位的酉门操作，作为量子电路执行程序。量子计算电路是量子逻辑门的网络，其中每个门对一个或多个量子位执行某种酉变换。在上一节中，您已经使用 Qiskit 看到了一些这样的门的例子。本节使用 Cirq [30]探讨类似的见解。

Cirq 是 Google 为量子计算机编程而创建的开源框架。它是“一个 Python 软件库，用于编写、操纵和优化量子电路，然后在量子计算机和量子模拟器上运行它们。”Cirq 为处理当今嘈杂的中等规模量子计算机提供了有用的抽象，其中硬件的细节对于实现最先进的结果至关重要。Cirq 文档位于 https://quantumai.google/cirq 。GitHub 直播在 https://github.com/quantumlib/Cirq 。

Cirq 在 Python 3.6.x(本书中首选的 Python 版本)中通过以下命令安装。

图 4-9

LTS Ubuntu 18.04 上的 Cirq 安装。(qml)是虚拟环境名

$ pip3 install cirq

图 4-9 显示了一个安装过程的例子，其中软件包被安装在一个名为qml的虚拟环境中。第一章描述了创建虚拟环境的方法。

一旦安装了 Cirq，就从同一个虚拟环境中打开一个 Jupyter 笔记本会话，并通过打印 Google 的cirq.google.Bristlecone和Cirq.ipynb中的代码来运行清单 4-2a 中的快速验证测试。Bristlecone 是一台谷歌量子计算机，他们用它实现了量子优势。每个刚毛设计芯片都有 72 个量子位。

import cirq
import numpy as np
print(cirq.google.Bristlecone)

Listing 4-2aBloch Sphere Simulation in Cirq.ipynb

该代码产生图 4-10 中的输出，确认 Cirq 安装成功。

图 4-10

Cirq 中的谷歌刺果酮

该电路由最初在∣0⟩态制备的单个量子位组成，用酉 x 门操作处理，然后在计算基础上再次测量量子位。

清单 4-2b 显示了定义 X 门的步骤。

# Get a qubit and a circuit
qbit = cirq.LineQubit(0)
circuit = cirq.Circuit()
# Add an X gate: acts like the Pauli Matrix sigma_x
circuit.append(cirq.X(qbit))

Listing 4-2bGenerate a Qubit and a Circuit Cirq.ipynb

在清单 4-2c 中，下一步，我们用cirq.Simulator()函数运行模拟。

# Simulation that extracts the wavefunction
sim = cirq.Simulator()
result = sim.simulate(circuit)
print("\nBloch Sphere of the qubit in the final state:")
state = cirq.bloch_vector_from_state_vector(result.final_state,0)
print("x: ", np.around(state[0], 4), " y: ", np.around(state[1], 4)," z: ", np.around(state[2], 4))

Listing 4-2cSimulation of Wave Function Cirq.ipynb

该代码生成量子位在其最终状态下的以下 Bloch 定义作为输出。

下一步，列出 4-2d ，为电路添加一个测量门。

# Add a measurement gate at the end of the circuit:
circuit.append(cirq.measure(qbit, key="Final state"))
# Display the circuit:
print("\nCircuit:")
print(circuit)

Listing 4-2dAdd Measurement on X Gate Cirq.ipynb

该代码产生以下电路作为输出，显示测量门为 M 。

这个实验的下一步(见清单 4-2e )使用模拟器并运行十次试验模拟来确定量子位的最终状态。

# Invoke the Cirq quantum simulator to execute the circuit
simulator = cirq.Simulator()
# Simulate the circuit several times:
result = simulator.run(circuit, repetitions=10)
# Print the results:
print("\nResults of 10 trials:")
print(result)

Listing 4-2eRepeated Simulations Cirq.ipynb

此代码的输出给出了以下最终状态。

这个例子使用 Cirq 模拟器的一个用户友好的特性，提取量子最终态波函数。这在真正的量子计算机上通常是不可能的，在量子计算机上你必须多次运行相同的电路才能到达最终状态。在本例中，最后一个州是∣1⟩.

用 Cirq 测量响铃状态

在本练习的前面，您已经在 Qiskit 中遇到了贝尔状态及其定义。您应该熟悉 Cirq 中响铃状态的产生和测量。有可能在计算基础上采用两个量子位的状态，并通过在第一个量子位上使用哈达玛门，然后在一对量子位上使用 CNOT 门，将它们转换成贝尔状态，如下所示。

)

(4.11)

)

(4.12)

)

(4.13)

)

(4.14)

在两个量子位的希尔伯特空间中，方程 4.11–4.14 中所示的幺正变换是从两个量子位计算基到贝尔态基的变换。如果以相反的顺序执行酉运算，则有可能从贝尔基旋转回到计算基。这个逆操作，接着测量量子位，被称为贝尔态测量。净效应是使用 EPR 对将两个量子比特的状态投射到四个贝尔态中的一个。电路如图 4-11 所示。清单 4-2f 是启动铃状态测量练习的代码。

图 4-11

纠缠 EPR 对上的门操作

# Get two qubits and a circuit
qubit = [cirq.LineQubit(x) for x in range(2)]
circuit = cirq.Circuit()
# Add a Hadamard gate to qubit 0, then a CNOT gate from qubit 0 to qubit 1:
circuit.append([cirq.H(qubit[0]),
cirq.CNOT(qubit[0], qubit[1])])
# Run a simple simulation that extracts the actual final states
sim = cirq.Simulator()

result = sim.simulate(circuit)
print("\nBloch Sphere of the qubit 0 in the final state:")
state = cirq.bloch_vector_from_state_vector(result.final_state,0)
print("x: ", np.around(state[0], 4), " y: ", np.around(state[1], 4), " z: ", np.around(state[2], 4))
print("\nBloch Sphere of the qubit 1 in the final state:")
state = cirq.bloch_vector_from_state_vector(result.final_state,1)
print("x: ", np.around(state[0], 4), " y: ", np.around(state[1], 4), " z: ", np.around(state[2], 4))

Listing 4-2fMeasurement on X Gate Cirq.ipynb

这个代码片段给出了以下输出。

然后，我们在电路中添加一个测量门，与 X 门中的一样。这显示在清单 4-2g 中。

# Add a measurement at the end of the circuit:
circuit.append(cirq.measure(*qubit, key="Final state"))
# Display the circuit:
print("\nCircuit:")
print(circuit)

Listing 4-2gMeasurement on X Gate Cirq.ipynb

以下电路作为输出打印出来，显示测量门为 M ，哈达玛门为 H 。

对于 Bell states 练习中的最后一步，我们运行模拟十次，与上一个练习相同。

# Run the Cirq quantum simulator to execute the circuit:
simulator = cirq.Simulator()
# Simulate the circuit several times:
result = simulator.run(circuit, repetitions=10)
# Print the results:
print("\nResults:")
print(result)

Listing 4-2hMeasurement on X Gate Cirq.ipynb

输出如下。

如果清单 4-4h 运行几次，每个量子位的结果随机变化，但是它们在两个量子位之间是 100%相关的。量子模拟器的结果来自最终态的计算基础中的 10 次测量，∣β00⟩，这是与爱丽丝和鲍勃相同的 EPR 对态。请注意，Cirq 报告说，两个量子位的最终状态都在布洛赫球的中心，而不是在其表面。

总之，关于 EPR 对，有一些事情需要记住。

• 量子随机性发生在窃听者(比如伊芙)和爱丽丝之间以及伊芙和鲍勃之间，但不发生在爱丽丝和鲍勃之间。

• 当 Alice 和 Bob 接收到相同的二进制位串时，Eve 当时不可能拥有他们的位串。

• 虽然是随机生成的，但它们共享的位串最终会产生很大的因果后果。

这种量子怪异被爱因斯坦称为“超距幽灵行动”

熵:经典与量子

熵被宽泛地定义为量化信号中信息的一种方式。简而言之，熵可以被解释为我们对给定系统状态的不确定性**或测量系统后我们获得的信息量。

香农熵

经典信息的关键概念是香农熵。克劳德·香农熵试图提供与给定状态∣ ψ _i ⟩， i ∈ {1… n }相关联的信号中的信息的统计表示。香农的理论是基于发现看到给定信息的概率。这使得科学家们能够表征从信号中获得的信息量。

Shannon 通过对给定消息的概率取以 2 为底的对数来量化所获得的信息量。如果消息中包含的信息用ι表示，其出现的概率用 p 表示，那么

??

其中，负号确保消息的信息内容保持为正。比如今天股市不暴跌 5%以下的概率是 0.9，那么新闻的信息量就是ι= log₂0.9 = 0.152。

形式上，如果 x ∈ { x ₁ ，x₂…x_n}是概率分布为p∈{p₁，p₂…

因此，如果给定的 x _i 的概率为 0，则香农熵为 0∫log 0 = 0。如果状态是纯的，香农熵估计其最小值为 0，如果是随机的，则取其最大值。状态的混合增加了熵。一般来说，下面的经验法则估计香农熵。

• 如果信息或消息的内容是确定的，那么香农熵为零。

• 下一条信息内容的不确定性越高，香农熵就越高。

换句话说，熵量化了我们测量 x 时获得的信息量。被称为二元熵函数 (BEF)的熵函数示例如图 4-12 所示。在信息论中，BEF 被定义为成功概率为 p 的伯努利试验的熵。在数学上，伯努利试验被建模为一个随机变量 x ，它只能取两个值:0 和 1。事件 x = 1 被认为是成功的，而事件 x = 0 被认为是失败的，其中两个事件是互斥且穷尽的。

如果 x = 1 的概率由Pr(x= 1)=p给出，那么 x = 0 的概率由Pr(x= 0)=(1-??)p 给出。在他的例子中， x 的熵由

)

(4.16)给出

其中对于二元运算，对数通常以 2 为底。

图 4-12

香农熵的二元熵函数

如图 4-12 所示，熵在)时达到最大值。最大熵出现在具有最少知识量的实例中。当每个可能的结果都是同样可能的时，那么离散概率 p _{* i *} 反映了关于测量结果的最少量的知识。因此，有了 n 个可能的结果，每个概率由

)

(4.17)给出

其中)的情况是无偏位的情况，无偏位是信息熵最常见的单位。清单 4-3 显示了用于生成图 4-12 中的情节的简单 Python 代码BinaryEntropyFunction.ipynb的片段。定义了概率和熵，并基于对数函数生成值以给出熵图。

# Import Libraries
import matplotlib.pyplot as plt
import math

# Define Probabilities and Entropy Functions
px0 = []
px1 = []
Sx0=[]
Sx1=[]
A=0.99
B=0.01
px0.append(1)
Sx0.append(0)

for i in range(99):
    V = math.log(A,2)
    J = math.log(B,2)
    Sx0.append((-A*V)+(-B*J))
    px0.append(A)
    px1.append(B)

   # Sx1.append(-A*(math.log(A,2)) -B*(math.log(B,2)))
    A -= 0.01
    B += 0.01
px0.append(0)
Sx0.append(0)

# Print the values and the graph
for i in range(20):
    print()
    print("p(x): ",end="")
    for j in range(5):
        print(str(px0[j*i+i])+",",end="")
print()

for i in range(20):
    print()
    print("S(x): ",end="")
    for j in range(5):
        print(str(Sx0[j*i+i])+",",end="")
plt.plot(px0, Sx0, color='blue')
plt.xlabel('P(X)')
plt.ylabel('S(X)')
plt.title('Binary entropy function')
plt.show()

Listing 4-3Libraries and Functions in BinaryEntropyFunction.ipynb

从数学上讲，如果 p = 0.3，那么找到替代方案的概率就是 1p= 0.7。

这表明在测量之前已经知道了状态，因为一个可能的值比另一个更有可能。在这种情况下，参考方程 4.2 ，我们有

)

另一方面，如果我们有 if p = 0.05，备选项的概率为 95%，那么我们得到

)

结果的完全不确定性意味着所有可能的结果都是同样可能的。一般规律是熵越大，测量前结果的不确定性越大。

冯·诺依曼熵

一个量子态的熵值是由香农熵的一个类似物决定的。这是通过使用密度算子而不是方程 4.1 中的概率分布元素来实现的。量子信息理论与经典理论有些相似，因为信息是由量子系统携带的。因此，这是有区别的，因为量子位在不止一种意义上携带信息。

• 经典比特可以被编码成量子比特。

• 由于不可克隆定理或可分辨性的限制，未知量子位可以携带隐藏和保护的信息。

如果我们回忆一下等式 1。29 在第一章中，混合量子系统的密度算符如下。

)

(4.18)

其中∣ψI⟩代表混合量子系统中一个系综中的 n 个可能态， p _i 是一个成员处于相应态的概率∣ψ_I⟩.

回想一下，密度算符是一种描述量子系统可能状态的方式，或者等效地说，是一种描述可能测量结果的方式，与概率分布非常相似。具有密度算符 ρ 的量子态的熵称为冯诺依曼熵，由

)

(4.19)给出

其中 Tr 描绘了密度算子的轨迹。

在具有密度态 ρ 和 ϵ 的混合系统中，相对冯诺依曼熵由

)

给出(4.20)

一般情况下，s(ρ|ϵ)≥0。只有当 ρ = ϵ 时才相等。

如果密度算符的特征值由λ_{I给出，那么冯诺依曼熵由}

)

给出(4.21)

一般来说，在 n 维中，量子态的熵遵循不等式。

)

(4.22)

量子系统中的复合态通常是由量子位态的张量积形成的态。如果一个复合态是可分的，那么它就形成了一个形式为 ρ ⊗ ϵ 的乘积态。在这种情况下，熵是可加的，由

)

(4.23)给出

一般来说，熵是次可加的。换句话说，复合系统的简化密度矩阵由不等式

)

(4.24)给出

方程 4.10 表明，要获得关于一个纠缠系统的最多信息，我们需要考虑整个系统；也就是说， S ( ρ )小于简化密度矩阵的组合熵，因为当考虑整个系统时知识增加了。拥有简化密度矩阵ρ1 和ρ2₂的用户在仅考虑系统的部分时对状态的了解较少。

状态的演变

由于它们固有的性质，在量子物理中，系统的状态通常随时间演化。在量子计算的电路和门模型中，状态按照酉矩阵运算演化(参见 1 章)。状态向量的演化相当于执行线性代数。在量子退火平台上，使用哈密顿量来模拟状态的演化(参见第一章)。有两种重要的状态:混合态和纯态。纯态具有这样的性质:它们总是可以被表示为一个状态向量与其自身的外积。混合状态一般表示为正交状态向量的和。在纯态下，冯·诺依曼熵永远为零，类似于确定性的香农熵。在混合态中，熵可以用一系列值来表示。

冯·诺依曼熵的性质可以总结如下。

1. S ( ρ ) = 0 当且仅当 ρ 为纯态。

2. 对于)(希尔伯特空间的维数)，S(ρ)= logN给出了 S ( ρ )对于最大混合态的最大值。

3. S ( ρ )在基变化下不变(即S(ρ)=S(UρU^{)对于任何酉矩阵 U )。}

4. For a set of numbers {λ_i} such that and λ_i > 0, and for a corresponding collection of density matrices {ρ_i} we have

   )

5. For a set of numbers, S(ρ) satisfies

   )

6. s(ρ_m⊗ρ_n)=s(ρ_m)+s(ρ**n)为独立

7. s(【123】)+()≤**

**** s()≤??(+***

***一个系统从纯状态发展到混合状态，然后又恢复到纯状态的实例可能有助于理解这个过程。在这个过程中，冯·诺依曼熵先增大，然后逐渐减小回到零。

第一步，我们定义自旋向上和自旋向下的状态向量以及由外积给出的纯态。这显示在清单 4-4a 中。这些库可以在qiskitStateEvo.ipynb,Jupyter 笔记本代码示例中找到，其中提供了完整的代码和额外的示例。我们用 Qiskit 来探索态的量子演化。

为了开始一些编码，我们调用qiskit库来展示 GHZ 状态。Qiskit是一个 Python 库，它创建量子电路，并在模拟器或 IBM 的量子设备上运行它们。

import numpy as np
from qiskit import *
import math as m
from scipy import linalg as la
%matplotlib inline

# Spin-up
u = np.matrix([[1],
               [0]])
# Spin-down
d = np.matrix([[0],
               [1]])
# Pure state |0><0|
P11 = np.dot(u, u.H)
# Pure state |1><1|
P22 = np.dot(d, d.H)

Listing 4-4aSpin-up, Spin-down Definition at qiskitStateEvo.ipynb

使用qiskitStateEvo.ipynb.中的清单 4-4b 绘制状态演变图

import matplotlib.pyplot as plt
p = np.arange(0.001, 1., 0.01)

# create list of von Neumann entropies
vn_y = list()
for value in p:
    rho_p = value*P11 + (1-value)*(P22)
    vn_y.append(von_neumann_entropy(rho_p))

# convert list of matrices to list of nos. for plotting
y = list()
for value in vn_y:
    y.append(value.tolist()[0][0])

# plot p vs. S(rho_p)
plt.xlabel('p')
plt.ylabel('von Neumann Entropy')
plt.title('S(rho_p)')
plt.plot(p, y, color='tab:red')
plt.show()

Listing 4-4bvon Neumann Definiton in qiskitStateEvo.ipynb

清单 4-4b 的输出如图 4-13 所示。

图 4-13

冯·诺依曼熵

图 4-13 的冯诺依曼图和图 4-12 的经典香农熵之间的比较表明，它们非常相似。

冯诺依曼熵的单参数密度矩阵族如清单 4-4c 所示。

# Define spin-up
u = np.matrix([[1],
               [0]])

# Define spin-down
d = np.matrix([[0],
               [1]])

# Define the pure state |0><0|
P11 = np.dot(u, u.H)

# Define the pure state |0><1|
P12 = np.dot(u, d.H)

# Define the pure state |1><0|
P21 = np.dot(d, u.H)

# Define the pure state |1><1|
P22 = np.dot(d, d.H)

# Define the mixed state |0><0| + |1><1|
I = (P11+P22)/2

# Define the pure state |0><0|+|0><1|+|1><0|+|1><1|
D = (P11+P12+P21+P22)/2

p = np.arange(0.001, 1., 0.01)

# Create list of von Neumann entropies
vn_y = list()
for value in p:
    rho = value*I + (1-value)*(D)
    vn_y.append(von_neumann_entropy(rho))

# list of matrices to list of numbers for plotting
y = list()
for value in vn_y:
    y.append(value.tolist()[0][0])

# plot p vs. S(rho_p)
plt.xlabel('p')
plt.ylabel('von Neumann Entropy')
plt.title('S(rho_p)')
plt.plot(p, y, color='tab:blue')
plt.show()

Listing 4-4cOne-Parameter Family in qiskitStateEvo.ipynb

清单 4-4c 产生如图 4-14 所示的输出。

图 4-14

单参数密度矩阵的冯·诺依曼熵

GHZ 状态

在量子信息理论中，GHZ 态代表 green Berger-Horne-zei linger 态，由 Daniel Greenberger、Michael Horne 和 Anton Zeilinger 于 1989 年首次研究[29]。它是一种特定类型的纠缠量子态，涉及两个以上的子系统(例如，粒子态或量子位)。GHZ 态是最大纠缠量子态。对于由 n 个子系统组成的系统，每个子系统都是二维的(即量子位)，GHZ 状态由

)

(4.25)给出

三量子比特 GHZ 态是最简单的一种。它表现出非平凡的多体纠缠。

)

GHZ 状态是所有处于状态 0 的子系统的量子叠加，所有子系统都处于状态 1，其中单个子系统的状态 0 和 1 是完全可区分的。

使用量子电路可以制备 1 GHZ。清单 4-4d 是 Jupyter 笔记本qiskitStateEvo.ipynb.中的 Qiskit 代码片段

from qiskit import *
import numpy as np
%matplotlib inline

qr = QuantumRegister(3)
cr = ClassicalRegister(3)
GHZ = QuantumCircuit(qr, cr)

GHZ.h(0)
GHZ.cx(0,1)
GHZ.cx(1,2)
GHZ.draw(output='mpl')

Listing 4-4dGHZ in qiskitStateEvo.ipynb

清单 4-4d 给出了 GHZ 输出的量子电路，如图 4-15 所示。

图 4-15

GHZ 量子电路

清单 4-4e 中 Qiskit 的Statevector()函数打印状态向量。状态向量用于使用 Qiskit 中的entropy()函数获得相应密度矩阵的冯诺依曼熵。Qiskit 中的DensityMatrix()函数被传递给GHZ_state ket 向量。

backend = Aer.get_backend('statevector_simulator')
GHZ_state = execute(GHZ,backend).result().get_statevector()
print(np.matrix(GHZ_state).H)

from qiskit.quantum_info import Statevector
psi = Statevector(GHZ_state)
print(psi)

Listing 4-4eStatevector in qiskitStateEvo.ipynb

现在可以使用 Qiskit entropy()函数计算冯诺依曼熵。这可以通过Statevector函数或DensityMatrix函数传递。在后一种情况下，输出实际上是零熵，而在第一种情况下，它正好是零。这是有意义的，因为态是纯态，密度矩阵计算为d=∣ψ⟩⟨ψ|。

值得注意的是在达到最终混合状态之前的中间时间点的最大值。一般来说，熵会随着时间的推移而增加。然而，在可以行使实质性控制的有效“封闭”量子系统中，熵可以降低到更低的水平(见清单 4-4f )。

from qiskit.quantum_info import entropy
vn_entropy1 = entropy(psi, base=2)
vn_entropy2 = entropy(D, base=2)
print(vn_entropy1)

Listing 4-4fEntropy in qiskitStateEvo.ipynb

下面显示清单 4-4f 的输出为 0。

从 GHZ 态的密度矩阵 D 给出的态演化到密度矩阵 ρ 描述的系统的熵可以通过列出 4-4g 来计算。

from qiskit.quantum_info import random_density_matrix
rho = random_density_matrix(8, rank=None, method='Hilbert-Schmidt', seed=None)
print(rho)

time = np.arange(0.001, 1., 0.01)

vn_entropy = list()
for t in time:
    vn_entropy.append(entropy(D, base=2)*t + entropy(rho, base=2)*(1-t))

# Create list of von Neumann entropies
vn_y = list()
for value in p:
    M = value*rho + (1-value)*(D)
    vn_y.append(entropy(M))

# plot p vs. S(rho_p)
plt.xlabel('time')
plt.ylabel('von Neumann Entropy')
plt.title('S(rho(t))')
plt.plot(p, vn_y, color='tab:blue')
plt.show()

Listing 4-4gEntropy Calculation of Evolved State in qiskitStateEvo.ipynb

输出曲线如图 4-16 所示。

图 4-16

演化 GHZ 系统的熵

在图 4-16 中，最大值出现在中间时间点，就在达到最终混合状态之前。一般来说，熵会随着时间的推移而增加。然而，在有效封闭的量子系统中，可以进行实质性的控制，熵可以降低到较低的水平。

再论不克隆定理

第章 1 讨论了量子力学的不可克隆定理，该定理指出量子态不能通过门操作等幺正变换直接复制或克隆。这意味着如果∣ ψ ⟩是一个量子态，而 U 是某种幺正变换，使得u∣ψ0⟩=∣ψψ⟩，那么这个性质不可能适用于任意态∣ ψ ⟩.该理论源于两个正交态(如单量子位情况下的∣0⟩和∣1⟩)和一个 U 的线性量子叠加的可能性，使得u∣ψ0⟩=∣ψ♀⟩和u∣ϕ0÷=∣9 如果我们考虑叠加)，那么

)

(4.26)

)

(4.27)

从方程 4.26 和 4.27 我们看到

)

(4.28)

本质上，不可克隆定理规定我们不能复制一个未知的量子态。然而，这并没有对复制一个已知的*量子态施加任何限制。的确，*这样做应该是可能的；实际上，它说我们可以准备同一个已知状态的许多相同的副本。不可复制定理对量子通讯有重大的影响，因为它暗示了要建构一个保存任意量子资讯的放大器是不可能的。不可克隆定理也使黑客无法复制信息和违反安全。

量子隐形传送

量子隐形传态是一个过程，通过这个过程，一个量子比特状态可以通过只发送两个经典比特的信息来传输。这个选项的工作原理是分发纠缠的量子粒子。这些纠缠在一起的粒子，一旦以可控的方式分布在两端，就产生了虚拟通道。

如图 4-17 所示，量子隐形传态是一种利用 EPR(爱因斯坦-波多尔斯基-罗森)源的纠缠贝尔对的现象[32]。

图 4-17

带测量电路的量子隐形传态

图 4-17 所示的电路是带测量的量子隐形传态*，初始状态为∣000⟩；通过应用 X 和 Y 门的随机幂，消息量子位被转换成非平凡状态。Alice 和 Bob 量子比特纠缠在一起成为 EPR 对。对消息和 Alice 量子位执行 Bell 测量。来自这个测量的经典信息然后控制 Bob 量子位上的两个单量子位操作。过程如下。*

• 发送者爱丽丝将一对纠缠粒子中的一个粒子发送到目的地，同时保留另一个粒子作为源。

• 对于一个窃听者 Eve 来说，不可克隆定理认为在不破坏纠缠粒子状态的情况下观察和测量它是不可能的。一旦她测量了一个特定的状态，测量的行为就会导致这个状态崩溃。换句话说，Eve 没有办法破坏安全。量子纠缠的这个特性使它成为一个安全的 ?? 通道。

• 理论上，不仅纠缠对的安全性很高，而且一对粒子也可以不受距离的影响而保持纠缠，甚至在宇宙尺度上。在实验中，量子纠缠已经被证明在空间和地球之间的距离达到大约 1200 公里，在地面实验中达到 50 公里[33]。

• 接收器 Bob 需要一个经典的开放信道来有效地解码量子数据，为此提出了 Eckert91 [34]类型的纠缠以确保严格的安全性。

• 爱丽丝首先通过量子通道将纠缠的量子比特∣b1⟩传送给鲍勃。

图 4-15 中的量子位 2 和 3 是 Bell 态的纠缠 EPR 对。

)

(4.29)

• 方程 4.25 中的∣b00⟩有下标 00，表示按照惯例，所有量子位都在∣0⟩.状态初始化

• Figure 4-15 shows the three-qubit state in five characteristic points of a quantum circuit. The input three-qubit state at point A is given by

  )

  (4.30)

• The first qubit is used as a control qubit, and the second qubit is the target qubit for the CNOT (Control-X) gate. Therefore, the state at point B becomes,

  )

  (4.31)

• The Hadamard gate (H) performs mapping on the first qubit.

  )

  (4.32)

• The state at point C is given by

  )

  (4.33)

• The second qubit is used as a control qubit. The third is a target qubit in the CNOT gate. The quantum state at point D is given by

  )

  (4.34)

• Finally, the state at point E is given by the following. (The first qubit is used for control and the third as the target for the controlled-Z gate.)

  )

  (4.35)

)

(4.36)

• 作为最后一步，对前两个量子位进行测量，这两个量子位被销毁，第三个量子位被传送到接收器。

• 目的地和源量子位之间的比较提供了正确的量子态被传送的结论。这种分析没有考虑量子通道引入的任何误差。

注意，传送状态是而不是叠加状态。因此，任何任意态的∣b1⟩都可以通过图 4-15 方案进行隐形传送。Alice 测量她的侧信道数据，并通过经典信道将其发送给 Bob。鲍勃使用图 4-15 中经典控制的泡利 X(或 CNOT)和 Z 门重建量子数据。这种情况本质上是安全的，因为

• 测量改变了纠缠粒子的状态。

• 攻击者需要访问量子和经典通道才能成功解码。

这部分是关于 Cirq 的实践课程，看看传送是如何工作的。编码练习表明，鲍勃量子位的最终状态保证是消息量子位最初所处的任何状态。这只有在 Alice 和 Bob 之间预先共享纠缠态的情况下才是可能的。

在下面的练习中，通过应用 X 和 Y 门，在随机状态下准备消息(量子位 0)。Alice 拥有消息量子位和量子位 1，量子位 1 是带有 Bob 的量子位 2 的 EPR 对的一部分。爱丽丝现在对她的一对量子位元进行贝尔态测量，得到四种可能的结果之一。然后，她将相当于两个经典比特的结果传输给 Bob。Bob 对他的量子位执行酉运算，这取决于他从 Alice 收到的信息。

在清单 4-5a 中，继续我们之前的 Cirq 练习，三个量子位、Hadamard 门和测量被定义为形成隐形传态电路，如代码体中所评论的。

import random
# Define three qubits: msg = qubit[0], qalice = qubit[1], qbob = qubit[2]
qubit=[0]*(3)
qubit[0] = cirq.NamedQubit('msg')
qubit[1] = cirq.NamedQubit('qalice')
qubit[2] = cirq.NamedQubit('qbob')
circuit = cirq.Circuit()
# Create a Bell state entangled pair to be shared between Alice and Bob.
circuit.append([cirq.H(qubit[1]), cirq.CNOT(qubit[1], qubit[2])])
# Creates a random state for the Message.
ranX = random.random()
ranY = random.random()
circuit.append([cirq.X(qubit[0])**ranX, cirq.Y(qubit[0])**ranY])

# Unitary operator rotating the two-qubit basis of the Message and Alice's entangled qubit;
# rotates the Bell state basis to the computational basis:
circuit.append([cirq.CNOT(qubit[0], qubit[1]), cirq.H(qubit[0])])
# Combining now with a measurement in the computational basis,
# we effectively have projected this two-qubit state onto one of the four states of
# the Bell state basis:

circuit.append(cirq.measure(qubit[0], qubit[1]))

Listing 4-5aTeleporation Circuit Definition Cirq.ipynb

下面使用来自贝尔测量的两个经典比特来恢复。

# Use the two classical bits from the Bell measurement to recover the
# original quantum Message on Bob's entangled qubit.
circuit.append([cirq.CNOT(qubit[1], qubit[2]), cirq.CZ(qubit[0], qubit[2])])
print("Circuit:")
print(circuit)

Listing 4-5bRecover Original Message in Bob’s Entangled Qubit Cirq.ipynb

这就给出了下面的隐形传态电路作为输出，类似于图 4-17 。

下一步类似于上一个关于贝尔状态的练习。我们管理 cirq。Simulator()来定义创建消息并输出 Bloch 球体位置的门(参见清单 4-5c )。

sim = cirq.Simulator()
# Simulation that applies the random X and Y gates to
# create the message.
q0 = cirq.LineQubit(0)
message = sim.simulate(cirq.Circuit([cirq.X(q0)**ranX, cirq.Y(q0)**ranY]))
print("\nBloch Sphere of the Message qubit in the initial state:")
expected = cirq.bloch_vector_from_state_vector(message.final_state,0)
print("x: ", np.around(expected[0], 4), " y: ", np.around(expected[1], 4), " z: ", np.around(expected[2], 4))

Listing 4-5cBloch Sphere Output Cirq.ipynb

例如，如果代码运行多次，输出结果可能会发生变化。

这种行为是量子力学概率性质的直接结果。

最后一步是找到最终状态的布洛赫球，如清单 4-5d 所示。

# Records the final state of the simulation.
final_results = sim.simulate(circuit)
print("\nBloch Sphere of Bob's qubit in the final state:")
teleported = cirq.bloch_vector_from_state_vector(
final_results.final_state, 2)
print("x: ", np.around(teleported[0], 4), " y: ",
np.around(teleported[1], 4), " z: ", np.around(teleported[2], 4))
print("\nBloch Sphere of the Message qubit in the final state:")
message_final = cirq.bloch_vector_from_state_vector(
final_results.final_state, 0)

print("x: ", np.around(message_final[0], 4), " y: ", np.around(message_final[1], 4), " z: ", np.around(message_final[2], 4))

Listing 4-5dBloch Sphere of the Final state Cirq.ipynb

最终输出给出了如下的布洛赫状态。

如果程式码执行几次，就很清楚讯息量子位元的最终状态永远不是∣0⟩就是∣1⟩，这是微不足道的，也是不可复制定理的表现。《星际迷航》的粉丝可能还记得，这就是为什么麦考伊博士反对在星舰企业号上使用传送装置，因为传送过程似乎会破坏原始信息，然后在其他地方瞬间重新创建！

我们进行测量的量子隐形传态电路的变体是相同的电路，但是没有测量。如清单 4-5e 所示，计算基础中省略了量子位 0 和 1 的测量。

# Unitary operator rotating the two- qubit basis of the Message and Alice's entangled qubit;
# rotates the Bell state basis to the computational basis:
circuit.append([cirq.CNOT(qubit[0], qubit[1]), cirq.H(qubit[0])])
# This time skip the measurement
# circuit.append(cirq.measure(qubit[0], qubit[1]))
# Use the same operations as before to recover the
# original quantum Message on Bob's entangled qubit.
circuit.append([cirq.CNOT(qubit[1], qubit[2]), cirq.CZ(qubit[0], qubit[2])])

Listing 4-5eTeleportation Without Measurement

没有测量的传送和有测量的一样有效。这是延迟测量的原理的体现，它意味着测量一个量子位的操作与使用它作为受控门操作的控制的操作互换。

隐形传态的基本工作方式包括用一个经典的通信通道来代替部分交换，这使得鲍勃的量子位可以任意远离爱丽丝的量子位。目前，传送的速度只受到一个事实的限制，即经典信息的传输速度不能超过光速。鲍勃可以选择在接收到来自爱丽丝的经典传输之前测量他的量子位，因为有 25%的时间，他已经有了正确的量子状态，而无需执行任何“校正”当爱丽丝的信息最终出现时，鲍勃知道他传送的信息是否有效。

远距离量子隐形传态不再是实验室里的思想实验。费米实验室与加州理工学院和美国电话电报公司合作，正在调试一个高保真、高速率的量子隐形传态系统，该系统使用近红外光子在标准电信光纤上移动，将两个时间仓叠加作为量子位。其他国家实验室正在开发类似的系统(见 Joe Lykken 课堂笔记[35])。

闸门调度

在我们深入第五章的量子算法的复杂性之前，让我们先解决一些大多数量子算法所基于的基础知识。本节介绍门调度和相关主题的指令级优化。对逻辑量子位的一系列门操作被称为时间表。逻辑量子位由一个或多个物理量子位组成，可以叠加，被认为比物理量子位有更多的相干时间。物理量子位是量子位的实际量子实现物理实现如电子或原子。就今天的技术水平而言，物理量子位面临着不完美和一致性的挑战。当前物理构建的多量子位系统的局限性可以通过从几个不完美的物理量子位构建一个逻辑量子位来克服。逻辑量子位可以用于编程，并可以由运行在台式机或笔记本电脑上的普通 CPU 上的模拟器来实现，以允许量子算法的开发、测试和调试。

量子电路的门之间有数据依赖。门控序列排序定义了门控之间数据相关性。对于图 4-18 中具有量子位 q1、q2 和 q3 的电路，如果它们共享一个逻辑量子位，门 G2 依赖于门 G1。

图 4-18

门控序列

一个量子位一次只能参与一个量子门。由于量子电路从左到右执行，数据相关性决定了量子电路中门的顺序和并行执行的顺序。背对背的两个顺序门通常具有明确定义的排序约束，换句话说，

如果门 A 和 B 都是任意的酉运算符，那么交换它们出现的顺序通常会产生不同的结果。在一些特殊情况下，酉矩阵有时可以排序，即使不总是等价的。在这些情况下，他们被认为是相互交换。

一般两个并排的平行浇口没有排序约束。在基于门的量子电路中，门调度的影响可能非常显著。许多算法的实现依赖于并行执行门来实现非平凡的加速。

量子算法中的门调度不同于它们的经典对应物，因为门调度为用户提供了额外的自由度。与经典指令调度相比，量子门调度的研究相对较少，提出的系统方法较少，因此，量子门调度是当前活跃研究的主题，试图找到更新的约束。

量子并行性和函数评估

量子算法的基本原理始于量子并行。量子并行性是许多量子算法的基本特征。在许多使用函数的情况下，重点是找到函数的结果。然而，在函数的特征或性质比函数评估更重要的情况下，量子算法比它们的经典部分更有优势。量子并行性允许量子计算机同时对 x 的许多不同值评估一个函数 f ( x )。换句话说，量子计算机可以在叠加态下对 f ( x )的各种值进行求值。

如果 f ( x )是一个以单比特为输入，单比特为输出的函数，那么 f ( x )就称为一个二元函数。因此，该函数只对 0 和 1 进行运算，其结果也是 0 或 1。

要定义函数，让，

)

比如恒等函数 f ( x ) = 0 当 x = 0 和 f ( x ) = 1 当 x = 1 和常数函数 f ( x ) = 0 和 f ( x ) = 1。位翻转函数也属于同一类: x = 0 时f(x)= 1x= 1 时 f ( x ) = 0。

身份和位翻转功能也被称为平衡，因为它们的输出在一半输入中是相反的。当 f (0) = f (1)时，该函数称为常数，而当f(0)^-1=f(1)时，该函数称为平衡。注意，陈述x→f(x)的运算通常不是酉运算，因此不适合量子计算。

一般情况下，给定一个函数的输出 f ( x )，并不总是可以反相 f ( x )得到输入 x 。换句话说， f ( x )的计算方式必须保证计算可以撤销。为了解决这个问题，第一个任务是将这些功能建模为量子电路。然而，我们不能简单地将任何门应用于一个量子位，因为根据量子力学的假设，所有的量子操作必须是酉和可逆(参见第一章)。

可逆幺正变换如图 4-19 所示。

图 4-19

酉变换(来源[35])

图 4-19 显示了酉变换，其中一个假想的酉变换U_f作用于两个量子位，使得

)

(4.37)

对方程 4.37 的解释表明，第一量子位保持不受U_f作用的影响。而第二量子位经受异或运算(由⊕算子给出)。

对于初始值 y = 0，我们从方程 4.37 得到如下。

)

我们可以证明U_{f是可逆的。如果我们再次对其输出应用 U f ，我们得到}

)

这里我们使用了模 2 特性，即f(x)⊕f(x)= 0(注意:模 2 运算状态:将相同的位相加两次并除以二，余数为零)。

请注意，我们将 U _f 视为“黑盒”或“神谕”(即 U _f 的内部细节与我们无关。一位先知描述了一个“量子黑盒”，我们假设我们可以实现和运行它，但不能“检查内部”来查看它的实现细节。在内部， U _f 由一个或多个量子门组成，甚至可能是一个电路，但我们通常不知道是哪些门或哪种电路。通过查询甲骨文(例如，通过发送输入和测量输出)，我们可以了解更多关于甲骨文的属性。因为预言是由量子门组成的，所以预言本身也需要是可逆的。

现在我们已经建立了算法的基础，可以解释量子并行性的基本原理了。

图 4-20

量子并行电路

1. Starting with two qubits at initial state |0⟩, as shown in Figure 4-20, we apply a Hadamard gate to the first qubit. This gives us

   )

2. The second qubit, also at initial state ∣0⟩, after the unitary transformation gives the final state ∣ψ_f⟩.

   )

)

从检查结果可以清楚看出，图 4-19 的电路同时包含了 f (0)和 f (1)的信息；换句话说，电路已经产生了一个叠加状态，该状态在一个单一步骤中具有关于 f (0)和 f (1)的信息。我们有所谓的量子并行性——在一次操作中同时获得两种状态的信息。

量子并行的例子表面上看起来很酷。但是，如果我们停下来想一想我们是如何获得任何信息的，比如这个系统的测量值，我们会看到一个迫在眉睫的问题:如果我们测量状态)，那么我们只获得一个值 x 和 f ( x )作为计算基础。在我们执行测量之后，我们获得的函数值是随机值 x 。因此，这个操作本身并不能提供非常有用的结果，因为我们甚至不能选择我们希望显示哪个值: f (0)或 f (1)。这就是 Deutsch 算法变得重要的地方。

多伊奇算法

平衡函数和常数函数已在上一节中描述。然而，找出一个函数是否确实是常数或平衡的往往是一个挑战！为了回答这个问题，大卫·多伊奇在 1985 年提供了一个很好的概念证明:在某些情况下，量子计算机比经典计算机更强大。Deutsch 算法[37]可以简单地用下面的框架来表述。

1. 确定 f (0) ⊕ f (1)的奇偶性值，其中⊕表示模 2 加法或异或运算；也就是说，1 ⊕ 1 = 0 ⊕ 0 = 0，1 ⊕ 0 = 0 ⊕ 1 = 1。

2. 证明如果 f ( x )为常数那么奇偶性为 0，如果 f ( x )为平衡，那么奇偶性为 1。

Deutsch 算法试图解决哪个/哪些给定函数是常数或平衡的。平衡和常数函数的属性是全局属性，因为为了比较行为，需要计算 f (0)和 f (1)函数(见图 4-21 )。

图 4-21

Deutsch 算法的电路 37

Deutsch 算法的主要目标是通过获得关于全局状态的信息来找到最终状态∣ψf⟩。该算法通过使用叠加态来实现这一点，该叠加态是系统由于量子并行性的性质而实现的。最终状态计算如下。

)

(4.38)

其中系统的初始状态是∣ψI⟩=∣01⟩，⊗照常表示状态的张量积。

以下是 Deutsch 算法的步骤。

1. Evaluate ∣ψ_i⟩ by applying Hadamard gates to the input states. By the definition of Hadamard gates, this action produces a product state of superposition. To calculate ∣ψ_i + 1⟩, we have the following.

   )

)

)

该操作创建一个叠加状态，包含组合的所有可能值( x ， f ( x ))。

1. In step 2, we apply U_f to ∣ψ_i + 1⟩ as follows.

   )

2. 在这一步，我们把我们的分析分成两种情况:当 f ( x )平衡时和当它恒定时。

   Case 1: f   (x) is constant ⇒ f   (0) = f   (1). Therefore, substituting f   (0) for f   (1) in ∣ψ_i + 2⟩, we have

   )

)

)

)

)老地方，老地方。这意味着量子位现在处于∣+ ⟩态。因此，

)

这意味着量子位 1 处于∣0⟩.状态因此，如果现在在标准基础上对量子位 1 进行测量，结果是完全确定的 0。

情况二: f ( x )平衡f(0)≦f(1)和 f (0) ⊕ 1 = f (1)和 f (1) ⊕ 1 = f (0)。

因此，

)

)

)

)

)老地方，老地方。这意味着量子位现在处于∣− ⟩态。因此，

)

这意味着量子位 1 处于∣1⟩.状态因此，如果现在在标准基础上对量子位 1 进行测量，结果是完全确定的 1。

总之，如果 f 恒定，Deutsch 算法给出 0 作为输出，如果 f 平衡，给出 1 作为输出。因此，该算法仅使用单个查询来确定 f 是平衡的还是恒定的。通过量子并行，无需显式评估同一函数的值即可计算该函数的全局属性。

带 Cirq 的 Deutsch 算法

现在你已经理解了 Deutsch 的算法，是时候用代码DeutschCirq .ipynb做一个练习了。清单 4-6a 中的程序随机选择函数 f ( x ) = 1 进行求值，并测量第一个量子位的最终状态。首先，我们导入库并构造一个函数来定义类似于图 4-20 的电路。清单 4-6a 定义了以下三个函数。

• main():生成一个函数(0，1) → (0，1)

  • 调用moracle将生成的函数映射到相应的 oracle

  • 用生成的神谕构建量子电路

• moracle():将函数映射到相应的 oracle

• deutsch_circuit():创建量子电路

  • 初始化两个量子位

  • 将 X 门应用于量子位 2

  • 对每个量子位应用哈达玛门以产生叠加

  • 应用神谕

  • 将哈达玛门应用于第一个量子位

  • 执行测量

import cirq
from cirq import H, X, CNOT, measure
import numpy as np
import random

def main():
    # Choose qubits to use.
    q0, q1 = cirq.LineQubit.range(2)

    # Pick a secret 2-bit function and create a circuit to query the oracle.
    secret_function = [random.randint(0, 1) for _ in range(2)]
    oracle = moracle(q0, q1, secret_function)
    print('Secret function:\nf(x) = <{}>'.format(
        ', '.join(str(e) for e in secret_function)))

    # Embed the oracle into a quantum circuit querying it exactly once.
    circuit = deutsch_circuit(q0, q1, oracle)
    print('Circuit:')
    print(circuit)

    # Simulate the circuit.
    simulator = cirq.Simulator()
    result = simulator.run(circuit)
    print('Result of f(0)⊕f(1):')
    print(result)

def moracle(q0, q1, secret_function):
    """ Gates implementing the secret function f(x)."""

    # coverage: ignore
    if secret_function[0]:
        yield [CNOT(q0, q1), X(q1)]

    if secret_function[1]:
        yield CNOT(q0, q1)

def deutsch_circuit(q0, q1, oracle):
    c = cirq.Circuit()

    # Initialize qubits.
    c.append([X(q1), H(q1), H(q0)])

    # Query oracle.
    c.append(oracle)

    # Measure in X basis.
    c.append([H(q0), measure(q0, key='result')])
    return c

Listing 4-6aDeutsch’s Algorithm First Step DeutschCirq.ipynb

接下来，在清单 4-6b 中应用 main 方法。这是运行程序并生成最终输出的方法。

if __name__ == '__main__':
    main()

Listing 4-6bGenerate Output DeutschCirq.ipynb

该代码在运行时会给出最终输出。

量子计算系统

本节旨在给出量子计算(QC)系统和相关关键组件的高级概述。今天的质量控制系统，不管种类如何(基于门控或退火)，都由所有平台通用的三个主要组件组成:硬件层、软件层和应用层。在门模型 QC 中，出于信息抽象的原因，软件层与硬件层耦合，并且可以进一步分类为虚拟层、用于量子纠错的层和用于寻址基于门的通用 QC 的编程底层的逻辑层。如图 4-22 所示，引用自琼斯、范·米特等人【39】。

图 4-22

量子计算系统的分层架构(来源[39])

今天的 QC 空间有各种平台，每个平台都支持某些领域的效率。应用程序可以从量子计算中受益。我们现在需要找到合适的设备。量子计算领域是一个广阔的领域，因此，不同的制造 QC 系统的公司已经取得了许多不同的进展。因此，许多不同的量子器件被开发出来，每一种都有自己的优点和局限性。开发应用程序时，了解哪种设备最适合解决特定问题非常重要。

一些最受欢迎的量子设备是基于门的量子计算机，其中使用量子逻辑门对量子位进行操作。你学习了编程和两种基于 gate 的属性，比如本章中的计算机，即 IBM Q(用于 Qiskit)和 Google Cirq。这种 QCs 使用的逻辑门类似于经典计算机中的逻辑门，但是更加复杂多样。你看到了盖茨的例子，包括哈达玛，泡利，CNOT 和旋转。

基于门的量子计算有许多不同的实现方式。

• 超导量子器件:最流行的使用噪声量子电路的硬件实现。它们需要用低温技术冷却到接近绝对零度(–273°C)。在这些类型的平台上工作的组织的例子有 IBM、Google 和 Amazon。

• 囚禁离子设备:这些平台使用囚禁离子作为量子位。这些设备往往具有非常高保真度的量子位，具有高得多的相干时间，但目前，与超导设备相比，量子位计数较低。专注于这类技术的公司的一个例子是 IonQ。

• 基于光子的设备:这些设备使用光子作为量子位。这些设备往往具有高保真度和快速门控操作，并且不需要制冷。致力于这些技术并取得重大进展的公司是 Xanadu 和 PsiQuantum。

另一种量子计算机使用退火技术。量子退火器，如 D-Wave 建造的量子退火器，在解决优化问题时非常有效。经典的背包问题、旅行推销员问题和最大割问题都可以通过这样的平台非常有效地解决。这是在量子退火机上完成的，首先将量子位初始化为叠加态。在这之后，量子位和它们之间的连接被慢慢调整。在运行结束时，配置对应于感兴趣的最佳解决方案。D-Wave 计算机的工作方式可以总结如下。

• 参数被转换成电压、电流和磁场。这个问题被编程到 D-Wave QPU(量子处理单元)上。

• 量子位自旋从它们的叠加态开始。

• 量子位自旋进化并探索问题空间。

• 当退火过程结束时，系统到达所提交问题的基态或低激发态。

• 读取自旋的状态，应用任何所需的预处理，并将结果返回给用户。

• 每秒钟可以做几百次。

量子控制中一些主要的挑战和国际研究兴趣的主题是量子纠错(QEC)相干性和量子存储器。一些量子计算机，如超导量子设备，容易受到噪声的影响，从而导致误差。这些误差分为三种主要类型:位翻转、相位翻转和读出误差。这些误差可以使用量子误差校正/减轻方法来校正；然而，这可能需要量子电路中额外的量子位和门。

开源软件在量子算法的设计和测试中变得至关重要[38]。许多工具由主要的商业供应商支持，目的是使开发 quantum 软件更容易。这反映了资金充足的开放机器学习框架如何使复杂模型的开发及其在同样复杂的硬件上的执行成为可能。现在有各种各样的量子计算开源软件，涵盖了量子工具链的所有阶段，从量子硬件接口到量子编译器，再到量子算法的实现，以及所有的量子计算范式，包括量子退火和离散及连续可变门模型量子计算。

门模型量子计算机通常具有如图 4-23 所示的工作流程。

图 4-23

门控模型 QC 中的工作流程(来源[38])

在门模型中，问题是在高层次上定义的。基于问题的性质选择合适的量子算法。接下来，量子算法被表达为一个量子电路，需要被编译成一个特定的量子门集合。最后，量子电路要么在量子处理器上执行，要么用量子计算机模拟器模拟。

图 4-24 显示了使用量子退火时的典型工作流程。

图 4-24

绝热 QC 中的工作流程(来源[38])

在量子退火过程中，作为第一步，问题被定义，然后被编码成 Ising 型哈密顿量，该哈密顿量被可视化为图形。第二步，通过小图嵌入将哈密顿问题嵌入到量子硬件图中。最后，量子退火器或经典解算器被用于采样对应于原始问题的(近)最优解的低能态。

图 4-23 和 4-24 中的过程从高层次的问题定义开始(例如，解决给定图上的旅行商问题或背包问题)。解决这样一个问题的第一步是决定一个合适的量子算法。量子算法被定义为解决一个问题的有限步骤序列，其中每个步骤都可以在量子计算机上执行。作为一个例子，在旅行推销员问题中，我们面临一个离散的最优化问题。因此，用户可以考虑一个适当的算法(例如，量子近似优化算法(QAOA) [40]，设计用于噪声离散门模型量子计算机或量子退火，以找到最佳解决方案)。

摘要

量子信息是指可以物理存储在量子系统中的数据。量子信息理论是研究这种信息如何被编码、测量和操纵的。本章介绍了 Qiskit 和 Cirq 中的基本算法、量子并行性、隐形传态和相关编程。下一章涵盖了量子机器学习基础的要点，如 Deutsch-Jozsa 算法，优化理论，信息编码和量子复杂性。***

五、QML 算法 1

你不能仅仅站着盯着水看就穿过大海。

—罗宾德拉纳特·泰戈尔

第一台量子计算机是几年前建造的。目前，QC 技术有多种平台可供选择，每种平台都在某些领域表现出效率。应用程序可以从量子计算中受益。你只需要找到合适的设备。开发应用程序时，了解哪种设备最适合特定问题的解决方案，以及在同一平台上哪种算法最受支持非常重要。

用量子计算推动经典机器学习的想法已经存在好几年了。这些想法几乎不像有些人认为的那样新颖或激进。事实上，D-Wave quantum annealer 的机器学习演示可以追溯到 2009 年[60]。

Note

在之前的章节中，我们进行了与 gates 和基本算法相关的动手编程，例如 Deutsch with Qiskit 和 Google 的 Cirq。在这一章中，我们用 Rigetti 的 Forest SDK 做了同样的事情。在接下来的章节中，我们将深入研究 D-Wave 的量子退火解决方案和 Xanadu 基于光子的量子机器学习库。

通过处理编码在所有可能输入的叠加中的量子信息，量子计算机可以同时计算每个可能输入的每个输出值。这叫做量子并行。量子计算和相关算法领域是通过 Deutsch 在 1985 年[37]基于 Feynman [41]的早期思想对通用量子计算的研究而开创的。该领域可分为与补充研究工作相关的不同部分，如。

• 开发用于计算和通信的量子算法

• 开发用于计算和通信的硬件

• 寻求鲁棒容错的解决方案

• 为机器学习开发量子算法

• 提高可扩展性

• 寻找普遍性的证据

彼得·肖尔(Peter Shor)在 1994 年提出了一种将数字因式分解为素数的量子算法。他的算法能够以比经典计算更快的速度完成任务。于是，实现量子计算机的可能性就成了安全问题。诸如 RSA 加密这样的代码，基于数学上未证实的复杂性假设被认为是有效安全的， ¹ 突然变得易受攻击；不再是因为不存在数学证明，而是因为一种新型的计算机，它的存在是物理定律所允许的。然而，矛盾的是，量子密钥分发(QKD)中的量子理论也提供了无条件安全问题的解决方案；即使是量子计算机也不能让量子密码变得不安全。

今天的量子计算机是嘈杂的(即，它们的量子位在物理层面上容易出错)，因此，它们的实际状态是不稳定的(即，状态在短时间内衰减)。此外，用于操纵量子位的门的实现容易出错(即，门不精确地操纵它所操作的量子位)，导致与预期结果的小偏差，并且这种错误在算法执行期间传播。量子位出错的现象被称为退相干。门是错误的现象被称为门不忠。

除了退相干、错误和不忠，当前构建物理量子计算机的技术在设备上的量子位数量方面具有有限的扩展能力。单个设备上超过一定数量的量子位以及控制和连接它们的工程方法会引入量子位和周围系统的干扰。因此，今天的量子技术的可扩展性仅限于(充其量)中等规模。嘈杂和中等规模的特性促使质量控制大师约翰·普雷斯基尔创造了术语嘈杂的中等规模量子 (NISQ)计算机【68】。

根据量子并行性和叠加态的定义，量子计算机在普适量子计算中的强大之处在于量子算法应该利用大量(尽可能多的)量子比特；否则，这些算法可以在经典计算机上模拟。然而，很大程度上由于工程和实际实现的限制，大多数 NISQ 时代的量子算法都以“低深度”告终。

深度是基于电路的量子计算的三个主要复杂性之一。计算复杂度可以根据机器用来完成所述计算的时间或空间量来指定。对于计算的电路模型，复杂性的一个自然量度是电路中使用的门的数量。第二个度量是电路的深度。电路复杂性的测量如图 5-1 所示。

图 5-1

一种深度为 3，空间为 4，宽度为 4，共有 5 个门的电路

如果我们将电路想象成被分成一系列离散时间片的*，其中单个门的应用需要单个时间片，则电路的深度是其时间片的总数。这不一定与电路中门的总数相同，因为作用于不相交位的门通常可以并行应用；例如，在同一时间片期间，一对门可以应用于两条不同线上的位。电路复杂性的第三个度量类似于图灵机的空间(或宽度)。这是电路中位或“线”的总数，有时称为电路的宽度或空间*。**

低深度算法也称为浅算法。按照现在的情况，如果一个算法需要很高的深度(深度算法)，它可以只利用几个量子位，那么它就可以被模拟。这意味着量子优势必须基于浅层算法(即仅使用几层并行门的算法)来显示。

今天的 NISQ 机器的物理量子位限制所强加的浅算法的低深度自动要求实现混合算法(即，被分成经典部分和浅量子部分的算法)。混合算法的经典部分和量子部分在一个循环中执行，结果在迭代之间得到优化[56] [69]。优化行为可能会影响混合算法的量子部分和经典部分[70]。

图 5-2 显示了混合算法的一般结构。它的量子部分使状态准备好被恰当地表示算法的酉变换操纵。酉变换产生的结果被测量并传递到工作流的经典部分。如果测量结果被认为是可接受的，则作为结果交付；否则，再次处理测量结果。输出作为输入传递给预处理步骤，该步骤相应地控制状态准备。

图 5-2

量子算法的一般结构(来源[48])

混合算法的结构遵循大多数量子算法的一般结构(即，由算法处理的量子态，如酉变换)，必须准备好，这通常需要经典的预处理。通过测量算法本身的结果产生的输出需要被再次处理(后处理)(例如，通过评估或改进其质量)。在许多情况下，后处理步骤不会启动另一个迭代(即，它不会将输入传递给预处理步骤)。

实现算法的电路应该在其上运行的目标 QC 平台影响整个算法，因为它可能支持与算法所假设的不同的门集，或者因为目标机器具有某些硬件限制。例如，以基于退火的平台作为目标量子机器的基于门的算法将不会是成功的实现。

在我们深入研究量子算法和机器学习的本质细节之前，最好了解更多关于量子计算复杂性的信息。

量子复杂性

你在第一章已经初步了解了计算复杂性。问题的复杂性指的是从算法、计算时间等角度来看，涉及占用资源的问题类别。为了估计总的计算成本，需要对资源进行分析。这是通过运行解决问题所需的算法来完成的。

计算机运行一个算法的时间就是该算法在特定计算平台上的运行时间。根据经典计算的基本原理，通过验证数据库中的项目直到找到一个期望的项目，可以获得数据库搜索目标的解决方案。这个练习需要时间复杂度为 O ( n )的最坏情况场景。

算法的计算复杂度是算法的时间、规模和相关资源需求如何随着数据集或问题规模的增长而发展的定量表达。算法旨在应用于未知函数或一组数据，以确定函数的属性(如周期或最小值)、因数或分类数据。

该函数的输入数量(即数据的大小)可以是从一位数到数万亿或更多。有很多算法可以选择。尝试它们，直到你找到似乎能完成这项工作的算法。一旦我们选择了一个我们认为适合我们的目的或目标的算法，我们需要决定对以下问题的响应:随着算法所操作的输入数量的增加，算法的运行时间会如何表现？这被称为算法对大小的敏感度*。*

随着算法问题规模的增长，它的运行时间也在增长。这被称为时间复杂度。以下是在下一章中讨论的各种时间复杂性。

• 恒定时间复杂度

• 多项式时间复杂度

• 非多项式时间复杂度

如果硬件电路可以随着数据集的增长而增长(或者利用大量现有服务器中的大量处理器)，那么计算所需的时间可能不会很长，并且可以用时间复杂度换取空间复杂度。

当谈到量子超越经典方法时，当前的兴趣是量子计算和通信领域的相对加速。为了实现这一点，通常，硬件黑盒类型的方法找出量子算法提供的时间优势(如果有的话)。

如果考虑到空间复杂度，那么算法中的电路在最坏的情况下是线性增长的 ??，而在大多数情况下是对数增长的 ??。任务是采用经典的昂贵的指数算法，并使用量子计算找到多项式算法*。因此，估计硬件的线性或对数增长被有利的时间成本所克服，因此可以忽略。*

量子复杂性理论的领域已经发展成为经典复杂性理论的扩展[44] [45]。它基于量子计算机是否在原则上能够更快地解决与运行时间复杂性相关的计算问题。

为了比较算法，习惯上使用度量或工具。一个这样的度量是渐近符号，有时被称为“大 ??”O 符号。这种符号表示执行给定计算任务所需的资源的估计值，以及当问题的规模变化时相同资源的变化特征。它没有给出需要多少资源的定性指示，而是一种渐进趋势。例如，考虑某个需要(25n2+n+21)个时间步长的特定算法，其中 n 是定义问题所需的位数。在这种情况下，它表示该问题具有由O*(n²给出的二次时间复杂度，因为 25 n ² 是到目前为止支配大 n 的那些步骤的最大因子。在将复杂度估计表述为O(n2 时，常数 25 被忽略，因为对于大的 n ，当将该算法与另一个算法的时间复杂度进行比较时，常数的重要性是微不足道的。*

渐近符号允许我们比较足够大的 n 的算法，当涉及到分类决策问题的理论时，它是一个重要的工具。这被称为计算复杂性理论，并根据他们最著名的解决方案的资源效率将计算问题分组在一起。这些组被称为复杂性类、，并且有很多这样的组。在本书的上下文中，只考虑了少数几个。当涉及到空间资源时，这些类都是有效的，空间资源在这里被定义为具有空间复杂度≤O(n^p)的问题类。随着问题的增长，不需要比多项式增加更多的内存。这个类被称为 PSPACE。时间效率以同样的方式定义:一个时间效率的解决方案需要几个与 n 中的多项式成比例的时间步长。当一个解决方案被称为高效时，这通常意味着该解决方案表现出时间效率和空间效率。

在这种情况下，运行时间优势被称为量子增强、量子优势，或者简称为量子加速。证明一个指数级加速被有争议地称为量子优势。

虽然量子计算的圣杯仍然是找到一个可证明的指数加速，但在渐近复杂性方面量子优势的更广泛定义为现实研究开辟了更多的途径，例如:

• 量子算法经常必须与经典采样进行比较，经典采样同样是非确定性的，并且与量子计算有密切关系。

• 定义明确的计算任务

• 这个问题的一个合理的量子算法

• 给任何古典主义竞争者的时间/空间

• 复杂性理论假设，并且可选地

• 一种验证方法，可以使用允许的资源有效地将量子算法与任何经典竞争对手区分开来

这里的似是而非的指的是近期硬件上的理想状态下的，可能包括处理噪音和实验缺陷的需求。

一个复杂性类是一组在某种意义上具有相似复杂性的决策问题，例如，可以用多项式时间或多项式空间解决的问题。

下面是一些主要的经典复杂性类。

• P :利用多项式时间，经典确定性计算机可以解决的一类问题。

• BPP :可以被经典随机化计算机使用多项式时间解决的问题，每个输入的错误概率)。

• NP :如果某个证明者提供一个多项式长度的“证人”，Yes 实例可以在多项式时间内被验证的问题类这一类中的一些问题是 NP 难问题，其中我们知道算法仍然以指数时间运行，但比暴力搜索快得多。一个例子是著名的旅行推销员问题(TSP)，我们在第八章中亲自解决了这个问题。还有 NP 完全问题，也就是说 NP 中的任何其他问题都可以在多项式时间内化简为它。因此 NP 完全问题是 NP 中最难的问题。一个例子是可满足性问题:如果证明者给我们一个满意的赋值，我们可以验证一个给定的 n 变量布尔公式是可满足的。因此它是 NP 完全的，可以证明它是 NP 完全的。其他例子有整数线性规划、旅行销售人员(在第七章中有一个真实的实现)、给图表着色的能力等等。

• PSPACE :经典确定性计算机利用多项式空间可以解决的问题。

所有类别的量子类似物也可以被定义，这是由 Bernstein 和 Vazirani [44]开始的努力。

• EQP :量子计算机利用多项式时间可以精确解决的一类问题。这个类依赖于计算中允许的一组基本门。

• BQP :量子计算机可以使用多项式时间解决的问题，每个输入都有错误概率)。这个类被认为是可以被量子计算机有效解决的*。*

• 量子 NP :一类问题，其中如果某个证明者提供了多项式数量的量子位的“量子见证”，则 Yes 实例可以被有效地验证。对于每个 Yes 实例，应该有一个量子见证以概率 1 通过验证，而对于 No 实例，应该以概率 1 拒绝每个量子见证。这个类也依赖于允许的基本门，并且利用每个输入的错误概率)，得到一个被称为量子梅林-亚瑟(QMA)的类。

• QPSPACE :量子计算机利用多项式空间可以解决的问题。它和经典的 PSPACE 一样。

量子特征图

经典的机器学习方法需要在不同的空间中处理它们的输入数据，以使其更容易处理，或者因为新的空间提供了便于相关模型分析的属性。支持向量机(SVM)就是一个例子。支持向量机使用线性超平面对数据进行分类。当数据在原始空间中已经是线性可分的时，线性超平面工作得很好；然而，对于许多数据集来说，这不太可能是真的。一种解决方法是将数据转换到一个新的空间，在该空间中，数据通过要素地图呈线性。

设 φ 为一组输入数据， ϑ 为特征空间。那么特征图ω被定义为

)

输出图上的输出数据点 φ ( x )称为特征向量。ϑ 通常是一个向量空间。转换关系如图 5-3a 所示。虽然在训练输入的原始空间中，来自两个类(红色正方形和绿色圆圈)的数据不能通过简单的线性模型来分离(左)，但是我们可以将它们映射到更高维度的特征空间，其中线性模型确实足以定义作为决策边界的分离超平面(右)。有关更多信息，请参见舒尔德和基洛兰[52]。

图 5-3a

量子特征空间变换

在量子特征图的上下文中，特征向量是量子状态。 ϑ 是希尔伯特空间的成员。映射ω:φ→ϑ应用酉变换 U 和变换x→∣φ(x)⟩.通常，在这种情况下， U 是一个变分电路，其转换如图 5-3b 所示。

图 5-3b

具有变分电路的量子特征空间变换

量子嵌入

通常，量子算法被输入产生结果所需的输入数据。这种输入数据必须表示为量子态，才能被量子计算机理解和操作。今天，量子机器学习的大多数应用程序使用量子特征映射来将经典数据映射到希尔伯特空间中的量子状态。这是设计量子算法的一个非常重要的方面，直接影响它们的计算成本。这个过程被称为量子 嵌入，涉及将经典 x 数据点转化为量子电路中的一组门参数，创建量子态∣ψx⟩.更多细节可以在[5]和[47]中找到。

图 5-4

从经典到量子嵌入

如图 5-4 所示，如果我们考虑经典输入数据由 P 个数据点组成，每个数据点具有 R 个特征，那么，对于数据集 D ，

)

其中， x ^p 为一个R-维向量， p = 1，2，…， P 。该数据可以嵌入或编码到 n 量子子系统中。这些子系统对于离散变量(DV)量子计算可以是 n 个量子比特，对于连续变量(CV)量子计算可以是 n 个量子比特。

信息编码

信息可以被编码成一个n-量子位系统，由一个状态以各种方式描述。通常，编码方法随着数据集的性质和要解决的问题而变化。对于量子机器学习和数据挖掘，编码的重要性是至关重要的。有相当多的编码方法。这本书主要关注以下内容:基本编码、振幅编码、张量积编码和哈密顿编码。本章着眼于这些编码方法的基本属性。它在未来的章节中对它们进行了扩展，即在章节 6 、 7 和 8 中，我们将探索它们与量子机器学习算法的关系。

根据目前的实践，输入准备有一个经典的部分，称为预处理，它创建了一个可以在量子计算机上处理的电路，以准备量子态。制备量子态的后一部分被称为态制备。在这种情况下，经典部分期间的 p 再处理的过程可以构成由人执行的手动任务或者由程序执行的自动任务。

为了将量子算法的输入准备为量子状态，定义了一个量子电路，它准备相应的状态。该电路可以在传统的预处理步骤中生成，如图 5-5 所示。

图 5-5

量子算法经典输入的准备(改编自[55])

生成的电路被预先添加到算法的电路中，发送到量子设备并执行。生成的电路用目标器件的量子指令语言表示，例如 Cirq、QaSM 或 Quil。因此，要评估给定算法在特定设备上的可执行性，必须考虑正确准备算法输入所需的额外门和量子位的工作量和复杂性。

参考文献[50]讨论了从经典数据生成制备任意量子态所需的门数。在这种情况下，在将经典数据编码成适于由量子算法处理的量子叠加态时，时间和空间复杂度的效率是至关重要的。

图 5-6 显示了经典数据驱动量子计算过程的三个一般执行阶段。

图 5-6

量子计算机执行的三个阶段

用于将经典数据加载到量子态以供量子计算机处理的量子电路是当前研究的活跃焦点。由于不同的量子算法对如何加载经典输入数据并将其格式化为相应的量子态有不同的限制，因此目前在该领域中使用了几种数据加载电路。

采用了各种编码技术，下面将解释其中的一些技术。

基本编码

基础编码是将二进制字符串形式的经典输入数据与量子子系统的计算基础状态相关联的过程。二进制或数字编码是将数据表示为量子位串，而模拟编码以状态的幅度来表示数据。如果数据必须通过算术计算来处理，数字编码是更可取的。另一方面，模拟编码是将数据映射到量子设备的大型希尔伯特空间的首选，这在机器学习算法中经常需要。在[52]中可以找到几种编码方案的简要概述，如基本编码、幅度编码或乘积编码，而[51]讨论了它们在量子机器学习中的使用。关于初始化任意量子态的一般机制的细节在参考文献[51]中给出。

基本编码主要用于在量子算法中必须对实数进行算术运算的时候。这种编码将实数表示为二进制数，然后在计算基础上将它们转换为量子态。

在基本编码中，实数 x ∈ ℝ由 k 个小数位近似，并转换成该近似的二进制表示。

)

其中 a _i ，a_—I∈0，1，实数的符号通过添加前导二进制数进行编码，如“0”代表“+”，1 代表 a。因此，实数近似为( n + k + 2)比特和一个( n + k + 2)维量子态。图 5-7 显示了基态的输入编码程序。

图 5-7

基本编码的输入准备(改编自[55])

以下是基本编码的步骤。

1. 第一步，对经典数据的预处理计算出二进制近似值a_sa_n…， a ₀ ，a_—1，a_—k实数，其中 a

2. 通过在量子位 i 上应用门)来产生相应的电路。这个电路创造了代表实数 x 的量子态。

3. 所生成的电路被预先加到算法本身的电路上(由图中的酉变换表示),并在诸如来自 IBM 或 Rigetti 的量子计算机之类的量子设备上执行。

每个基本状态的振幅值的唯一目的是以足够高的被测量概率来标记或标示计算结果；他们没有携带其他信息。基本编码方法的量子算法的目标是增加对应于对解进行编码的基本状态的振幅的概率或绝对平方。

任何向量 x = x ₁ ， x ₂ ，…x_n∈ℝⁿ都可以通过计算其每个分量 x _i 的基编码映射成一个基编码作为一个例子，让我们尝试二进制分数表示，其中区间[0，1]中的每个数由一个 T 位串表示，根据

)

在这种情况下，要在基本编码中对向量(0.7，0.1，1.0) ^T 进行编码，首先需要将其转换为二进制序列，其中选择精度为 T = 4 的二进制小数表示，第一位对符号进行编码，如下所示:0 表示 a +, 1 表示 a–。

)

)

)

因此，向量(0.7，0.1，1.0) ^T 转化为二进制序列 11011 01001 01111，并在基本编码中编码为∣ x ⟩ = ∣ 11011 01001 01111⟩。

当一个数据集 D = { x ¹ ， x ² ，…，x^p}为二进制嵌入时， D 在二进制编码中的表现为 D 元素的二进制编码状态的均匀叠加。

)

关于创建这种叠加的时间复杂度为 O ( mn )的算法，请参见参考文献【56】。二进制编码状态的数据集的状态表示的单个元素 D = { x ¹ ， x ² ，…，x^p}⊆ℝⁿ可以通过下面的量子随机存取存储器(QRAM)表示来访问。

)

例如，对于一个包含两个例子x1= 10 和x2= 01 的经典数据集，对应的基编码用两个量子位表示∣ x ¹ ⟩ = ∣ 10⟩和∣ x ¹ ⟩ = ∣ 01⟩，给出

)

参考文献[57]提出了一种实现这种时间复杂度为O(logp)的 QRAM 的架构。来自ℝ ⁿ 的数据可以以复杂度)编码在其存储单元中。

振幅编码

振幅编码技术涉及将数据编码成量子态的振幅。虽然量子算法对数据的算术操作不是最重要的，但更紧凑的数据表示是有用的。具体来说，量子器件的大希尔伯特空间在这种编码中得到了恰当的利用。在这个方案中，归一化的经典 N 维 x 数据点由一个 n 量子比特量子态|ψ_x⟩的振幅表示为，

)

其中 x _i 是 x 的第 i 个元素，| i ⟩是第 i 个计算基态，n= 2ⁿ。

这种编码需要 log₂T2n 个量子位来表示一个 n 维数据点。

例如，如果我们希望使用幅度编码对四维浮点数组 x = 1.5，0.0，5.0，0.0 进行编码，那么第一步是以下列方式对其进行归一化。

)

那么对应的幅度编码用两个量子位来表示x_{范数 为}

)

)

如果我们考虑前面的经典数据集 D = { x ¹ ， x ² ，…，x^p}，那么如果我们把所有的输入实例 x ⁱ 串联在一起成为一个向量，就可以完成它的幅度编码。

)

其中， c _范数 为归一化常数，归一化准则为| α | ² = 1。输入数据集在计算基础上表示为

)

其中， α _i 为振幅向量 α 的元素。∣是计算的基态。要编码的振幅数量由 N × P 给出，并且由于一个 n 量子位的系统与 2 个 ⁿ 振幅相关联，振幅编码需要N≥log₂NP数量的量子位。

在幅度编码期间，可以通过酉变换u=u₁⊗u₂⊗…⊗u_k来创建状态，其中每个 U _i 或者是一个单量子比特门或者是一个 CNOT，并且 k 是在这种情况下， x _i 可以有不同的数值数据类型(如整数或浮点)。

如果要从| 0⟩基态(即| x ⟩ = U | 0⟩)准备好 x ，那么 2 个 n 门就足够了，如申德和马尔科夫所示[50]。对于满足某些约束的 x ，这种复杂性可以进一步降低。例如，Soklakov 和 Schack [58]给出了单位长度状态的多项式算法，这些状态是特定有界的(即，如果应该避免制备量子态的指数复杂性，则只能制备有限的一组状态)。Schuld 等人[59]提出了一种不一定是单位长度向量的幅度编码，它特别显示了如何通过填充来消除经常做出的假设 n 是 2 的幂。

即使振幅编码仅需要( log ₂ n )个量子位来编码x∈Rⁿ)，但是这种状态的准备通常是指数级昂贵的。

张量积编码

与振幅编码不同，张量积编码需要 n 个量子位来表示 n 维数据，但就复杂性而言，准备起来更便宜，因为它需要每个量子位旋转一次。这种编码对于在量子神经网络中处理数据是直接有用的，并且在本文中被称为参考文献[5]中的角度编码。图 5-8 显示了张量积编码的过程。

图 5-8

张量积或角度编码的输入准备(改编自[55])

图 5-8 中的过程如下。

设 x = x ₁ ， x ₂ ，…，x_n∈ℝⁿ。每个分量 x _i 上的张量积编码由下式给出

)

这给出了以下完整的矢量表示

)

(5A)

第一章讨论了泡利矩阵和旋转算子。当对泡利 X、Y 和 Z 矩阵求幂时，产生旋转算子，其将布洛赫绕 X、Y 和 Z 轴旋转给定的角度 θ 。

)

)

)

将酉r_y(2x)应用于图 5-6 中的矢量∣ x ⟩。

)

它意味着以下内容。

)

反过来，前面的等式意味着

)

(5B)

这里我们从方程 5a中得到原始向量∣ x ⟩。在方程 5 B ，)是r_y(2x_I)与状态∣0⟩在整个 i 范围内的张量积。

预处理步骤可以生成图 5-6 的电路，使得状态准备步骤准备 x 的量子表示。然后，电路可以作为代码生成，预先添加到算法本身，发送到量子计算机，然后在那里执行。

哈密尔顿编码

量子多体系统(将在本章后面讨论)展示了极其多样的相位和物理现象，这构成了物理学及其他许多领域的中心研究对象。哈密顿量 编码通过对量子系统演化中的信息进行编码，使用一种隐含的技术。后面章节中的量子机器学习算法使用哈密尔顿编码和一些其他的量子程序。在本书的剩余部分，我们将通过一个例子驱动的方法来更严格地研究它们。

第四章介绍了一些著名的量子算法，比如 Deutsch 的算法。我们在这一章中介绍一些更多的量子程序。

Deutsch-Jozsa 算法

1992 年的Deutsch–Jozsa 算法[41]启发了 Shor 和 Grover 的工作，可能是最著名的量子算法，并且基于 Deutsch 的算法[37]，David Deutsch 和 Richard Jozsa 将其扩展为更令人信服的算法分离，成为现在所谓的 Deutsch-Jozsa 算法。格罗弗 1996 年的算法是用于搜索数据库 42 章和本章后面讨论)。这些想法的共同点是，它们说明了量子信息处理为纯经典术语定义的问题提供解决方案的潜力，这些问题被认为无法通过经典信息处理有效解决。与量子密码术为经典通信所实现的类似，量子算法提供了执行某些经典计算的潜在更好的方法，即使在中间阶段，通信和计算都将依赖于量子资源和处理。

基本上，量子算法有两个主要类别:基于量子傅立叶变换 (QFT)的算法，对应于隐藏子群问题和量子搜索算法的一般实现。Shor 和 Deutsch–Jozsa 算法属于前一类，而后者由 Grover 算法的变体组成。不属于这两类算法的一个例子是量子模拟。在这种情况下，量子计算模拟了一个量子系统，正如费曼最初设想的那样[41]。

模拟哈密顿量的概念是定义量子计算的最方便的起点。量子化谐振子俗称 qumodes 。量子信息有两种常见的编码。通常所知的是基于离散的二能级系统——因此，被称为量子比特。另一种方法依赖于无限维量子系统，如量子化谐振子(也称为 qumodes )，这些更让人想起经典的模拟编码。基于量子位编码的方案通常被称为离散变量(DV)方法。相比之下，那些利用无限维系统以及根据具有连续光谱的变量制备和测量量子信息的可能性的方案被称为连续变量 (CV)方案。

我们在第 1 和 4 章中研究了量子并行性、纠缠和多伊奇算法，以及一些相关的编码示例。一个态中的纠缠量子位| ψ _ent ⟩，根据定义，不再是可分的，计算基础由下式给出

)

(5.1)

其中，λ_I∈ℂ，对于I= 1…2ⁿ和)。基底{| 0…00⟩…| 1…11⟩}定义了第 n 个量子位的计算基础。

在方程 5.1 中，使用了以下表示张量积的常用约定:∣x⟩⊗∣y⟩=∣xy⟩.下面在计算基础上的狄拉克矢量表示也非常有用。

)

(5.2)

我们从纯粹基于量子电路的角度来看 Deutsch 的算法。如果你更熟悉量子力学的基本原理，通过图 5-9a 所示的费曼图中的路径，对同一问题进行另一种可视化可能是有用的。

图 5-9a

多伊奇算法:费曼路径图

为简单起见，让我们使用图 5-9b 中电路所示的简化相位甲骨文模型。

图 5-9b

多伊奇算法:图 4-20 的简化阶段甲骨文模型

以下步骤根据图 5-2a 总结了图 5-2b 的电路的每一步的量子态。

1. 输入是∣0⟩

2. )

3. )

   )

4. )

在表达式(1) ^{f (0)} 中，是一个称为量子位的全局相位的常数因子。从测量的角度来看，全局相位可以忽略，因为量子态的全局相位是不可检测的。在量子力学中，只有能量差，而不是物理系统动力学的绝对值，才是重要的。一个经典的类比是电子在导线中的运动，在导线中只测量电压差，而不是绝对值。这说明如果 f (1) = f (0)最终测量的结果总是 0，如果f(1)≦f(0)最终测量的结果总是 1。

Deutsch 的算法可以用所谓的相位反冲来很好地解释。相位反冲方案考虑输入| x ⟩|−⟩，for x ∈ {0，1}，并将 Oracleu_f应用于该输入。对于∣ ψ ⟩州来说，这给

)

)

)

(5.3)

等式 5.3 可以被认为是针对单输入的多伊奇算法的一般情况(参见第四章)。对于方程 5.3 ，可以有两种不同的情况: f ( x ) = 1 或者 f ( x ) = 0。如果 f ( x ) = 0，等式 5.3 给出

)

这表明输入| x ⟩|−⟩在 U _f 的作用下保持不变。相反，如果 f ( x ) = 1，则等式 5.3 给出

)

这表示输入| x ⟩|−⟩.增加了一个相位(1)这两种情况可以用下面的表达式来概括。

)

(5.4)

方程 5.4 是相位反冲方程。

Deutsch 算法的解决方案是精确的，因为它产生错误概率为零的正确答案，并且它只需要一个 oracle 查询，因此它的时间复杂度为常数 O (1)。该算法采用了 n + 1 个量子位，给出了线性内存消耗 O ( n )。

当 f : {0，1} → {0，1}作用于一个不太有趣的单输入位时，Deutsch 的算法工作得很好。感兴趣的是更一般的场景，其涉及用于确定函数 f : {0，1} ⁿ → {0，1}的性质的量子算法的设计和分析，该函数作用于多个输入值。这有可能提供超越任何经典确定性解决方案的指数级加速。

Deutsch-Jozsa 算法是 Deutsch 算法的 n 位推广。这个算法和 Deutsch 的算法一样，确定一个函数 f ( x )对于多个输入值是平衡的还是常数。如果 f ( x )不变，则 x 的所有输入值的输出都相同(即 f ( x )始终为 0，或者 f ( x )始终为 1)。如果 f ( x )平衡，则对于一半的输入， f ( x ) = 0，对于另一半的输入， f ( x ) = 1。

在经典计算期间，通常在最坏的情况下，需要查询(2^n—1+1)次，需要超过一半的域{0，1} ⁿ 的输入，以确定 f ( x )是平衡的还是恒定的。当使用随机化算法时，该练习可能会在)个查询的结果上实现有界误差 ε 。

对于一个量子解决方案，图 5-10 中显示了一个费曼图，便于跟踪量子态。

图 5-10

Deutsch-Jozsa 算法:费曼路径图

下面的步骤总结了图 5-3 中每一步的量子态，这类似于 Deutsch 算法的费曼图中的路径。

1. 输入状态是∣ψ0⟩=∣0⟩^⊗n

2. )

3. )

步骤 3 的扩展给出了步骤 4。

)

)

)

)

其中， H 照常是哈达玛变换。

类似于图 5-11 的电路用于一般量子解的 Deutsch-Jozsa 算法。

图 5-11

Deutsch-Jozsa 算法的量子电路

在图 5-11 中，一般的 Deutsch-Jozsa 算法是通过以下步骤推导出来的。

1. 输入状态为∣ψ0⟩=∣0⟩^{⊗n⊗∣1⟩}

2. Then, the Hadamard gates are applied, giving

   )

3. The state from step 2, after analysis, gives

   )

4. After applying Hadamard transformation to all the n qubits, we have

   )

   (5.5)

前面的步骤给出了以下内容。

)

最后，测量状态∣0⟩^{⊗n的概率由下式给出}

)

如果f(I)=常数，那么我们得到相长干涉，这就得到p(|0⟩^⊗n)= 1。如果 f ( i )是平衡的，那么相消干涉给我们的概率是 0。

总之，Deutsch-Jozsa 算法之所以有效，是因为以下原因。

在案例 1 中，神谕是常数。在这种情况下，就全局相位而言，它不会影响输入量子位。H 门是它自己的反向门，因此

在第二种情况下，甲骨文是平衡的。在这种情况下，在步骤 2 之后，输入寄存器是计算基础中所有状态的相等叠加，并且相位反冲将负相位添加到这些状态的一半。

)

(5.7)

这表明查询 oracle 后的量程状态与查询 oracle 前的量程状态正交。同样地，应用 h 门给出了与全零∣000…0⟩态正交的量子态，这意味着 al-零态不应该被测量。

Deutsch-Jozsa 算法的量子查询复杂度。求解多伊奇问题时最小化的代价函数是应用于 U _f 的量子查询的数量。这是量子查询复杂性模型的一个例子，许多量子算法都是用它开发的。在量子查询复杂度的研究中，给一个黑盒 U _f 实现函数 f ，询问对 U _f 的最小查询次数是多少，以确定 f 的一个期望性质。注意，计算该属性的量子算法可以包括例如 999999999 个量子门；如果它只包含对 U _f 的两个查询，那么我们认为算法的代价为 2(即所有“非查询”操作都被认为是免费的)。

有 Cirq 的 Deutsch-Jozsa

第四章包括对谷歌开源量子计算库 Cirq 的实际介绍，其中大部分内容都局限于构建电路、门，最后是 Deustch 的算法。本章尝试用 Cirq 构造一个两比特 Deutsch-Jozsa 算法。Deutsch-Jozsa 算法可以使用对 oracle 的单个查询来区分常数和平衡函数。这个练习的目标是写一个可以区分这些的量子电路。

我们首先导入所需的库，如清单 5-1a 所示，用于可以从该书网站下载的Deutsch-Jozsa_cirq.ipynb Jupyter 笔记本。

import cirq
import numpy as np
import matplotlib.pyplot as plt

Listing 5-1aLibraries for Deutsch-Jozsa_cirq.ipynb

在关于 Deutsch 算法的讨论中，您看到了一个输入位的布尔函数要么是常数，要么是平衡的。然而，我们也从 Deutsch-Jozsa 算法部分看到，对于两个输入位的布尔函数，不是所有的函数都是常数或平衡的。有两个常量函数( x ₁ 、 x ₂ ) = 0、 f ( x ₁ 、 x ₂ ) = 1、)平衡函数。下面的代码给出了这些函数的操作，其中我们取两个输入量子位并计算第三个量子位中的函数。

# Define three qubits to use.
q0, q1, q2 = cirq.LineQubit.range(3)

# Define the operations to query each of the two constant functions.
constant = (
    [],
    [cirq.X(q2)]
)

# Define the operations to query each of the six balanced functions.
balanced = (
    [cirq.CNOT(q0, q2)],
    [cirq.CNOT(q1, q2)],
    [cirq.CNOT(q0, q2), cirq.CNOT(q1, q2)],
    [cirq.CNOT(q0, q2), cirq.X(q2)],
    [cirq.CNOT(q1, q2), cirq.X(q2)],
    [cirq.CNOT(q0, q2), cirq.CNOT(q1, q2), cirq.X(q2)]
)

Listing 5-1bInput States for Deutsch-Jozsa_cirq.ipynb

接下来，我们为量子电路定义一个函数，它可以在两个比特上区分常数和平衡函数。

# Define a function

def deJo_circuit(oracle):
    # Phase kickback trick.
    yield cirq.X(q2), cirq.H(q2)

    # Get an equal superposition over input bits.
    yield cirq.H(q0), cirq.H(q1)

    # Query the function.
    yield oracle

    # Use interference to get result, put last qubit into |1>.
    yield cirq.H(q0), cirq.H(q1), cirq.H(q2)

    # Use a final OR gate to put result in final qubit.
    yield cirq.X(q0), cirq.X(q1), cirq.CCX(q0, q1, q2)
    yield cirq.measure(q2)

Listing 5-1cFunction Definition for Deutsch-Jozsa_cirq.ipynb

然后，我们通过运行以下单元来验证我们的 Deutsch-Jozsa 电路，该单元模拟所有 oracles 的电路。

simulator = cirq.Simulator()

print("\nResult on constant functions:")
for oracle in constant:
    result = simulator.run(cirq.Circuit(deJo_circuit(oracle)), repetitions=10)
    print(result)

print("\nResult on balanced functions:")
for oracle in balanced:
    result = simulator.run(cirq.Circuit(deJo_circuit(oracle)), repetitions=10)
    print(result)

Listing 5-1dRun Cirq Simulator to Verify Deutsch-Jozsa_cirq.ipynb

下面的输出显示，对于不同的 oracles，该电路按预期工作。

正如 Deutsch 的算法使用一位的情况一样，对于常数函数，我们总是测量 0，对于平衡函数，我们总是测量 1。

量子相位估计

相位估计是一个量子例程，帮助找到酉矩阵的特征值 U 应用于作为受控门的量子寄存器。相位估计使用 QFT 来写入以振幅的相位编码的信息。通常，量子机器学习 (QML)算法使用这种技术来评估包含 QML 训练集信息的算子的特征值。

上一节快结束时，我们注意到 Deutsch 算法和 Deutsch–Jozsa 算法中的最后一个 Hadamard 门用于获取状态相对相位中的编码信息。哈达玛门是自反的(参考方程 5.6 和 5.7 )，因此反其道而行之；也就是说，它可以将信息编码到相位中。

让我们来看看我们对方程 5.5 的哈达马状态的推导，然后考虑一个 h 门作用于基态∣ x ⟩，对于 x ∈ {0，1}，那么，对于 n = 1，从方程 5.5 ，

)

(5.8)

哈达玛门可以被认为是保存了关于基态∣0⟩和∣1⟩.之间的相对相位的值的编码信息由于哈达玛门是自反的，将其应用于等式 5.8 右侧的状态，我们又回到了状态∣ x ⟩，

)

(5.9)

因此，在方程 5.9 中，哈达玛门可以被认为是解码关于相位中编码的 x 值的信息。同样，如果我们考虑h⊗n作用于一个 n 量子比特基态∣ x ⟩，那么我们得到等式 5.5 的等价式，即

)

(5.10)

因此，n-量子比特哈达玛变换可以被解释为将关于∣ x ⟩的值的编码信息处理成相位(1)^x。y∣y*⟩.注意(1) ^{x 。 y} 是一种非常特殊形式的阶段。一般来说，相位是一个形式为e2πIω*的复数，其中 ω ∈ {0，1}为任意实数 ω 。这允许)在相位为 1 时。一般来说，n-量子位哈达玛变换不可能完全访问以比相位更一般的方式编码的信息。然而，可以编写一个特殊的程序，允许哈达玛门确定相位编码的信息。

设∣ ψ _n ⟩， n = 1，2，…, n 为酉算子 U 的特征向量。 U 定义在∣ψ_n⟩构成正交基的希尔伯特空间中。受控 U 对特征向量的酉运算给出，

)

(5.11)

其中 ω ∈ {0，1}为任意实数 ω 。等式 5.12 成立，因为酉算子的 e 特征值是相位。

为了形象化方程 5.12 ，我们可以考虑由下式给出的初始状态

)

(5.12)

为了进一步分析表达式 5.12，我们需要考虑基本编码。

考虑到 j 位串为 0 到(2j1)的整数，∣ y ⟩参考∣ y ⟩标注的基态，其中 y 为整数 y 的二进制编码。查看等式 5.12 ，确定值，或者至少是相位参数 ω 的适当估计，必然会有兴趣找到 ψ 。这就是相位估计问题【43】。为了解决这个问题，相位估计例程允许以下变换

)

(5.13)

其中)是对 ω 的估计。等式 5.13 暗示正交∣ψ_n⟩的特征值对于 ω _{* j *} 如下。

)

(5.14)

我们需要记住，既然是 U 酉，λ_j必然有 1 的量级。我们从二进制定义 ω 开始，

同样， ω 的二次方倍数可以写成

)

(5.16)

对于方程 5.12 的相位部分，我们也知道 e ^{2 πik} = 1 对于任意整数 k ，我们有

)

)

)

(5.17)

现在，如果我们有一个给定的输入状态)，并考虑一个量子电路来确定对 ω 的估计，那么，对于一个一量子位的输入状态，其中 j = 1，我们有 ω = 0。p1 及以下由等式 5.5 得出。

)

)

)

)

(5.18)

求解相位估计的电路如图 5-12 所示。

图 5-12

相位估计电路

在图 5-12 中，经过受控的 U 变换后，特征向量保持不变，特征值 λ 包含在第一个量子位的相位中。在第一量子位上的哈达玛变换将信息转换成可以测量的振幅。换句话说，参考等式 5.9 和 5.18 ，确定p1 的值并估算 ω ，我们有

)

(5.19)

既然你已经完成了一个单量子比特输入的相位估计练习，让我们来看看一个两量子比特的状态。

)

(5.20)

等式 5.20 表明p2 可以通过以与等式 5.19 中相同的方式对第一个量子位应用哈达玛门来确定。但是还需要确定 p ₁ ，在那个过程中涉及到第二个量子位。如果 p ₂ = 0，那么第二个量子位处于)状态，由此可以确定 p ₁ 。然而，如果 p ₂ = 1，那么就有一个挑战，因为前面的直接方法将不起作用。为了实现它，我们需要应用相位旋转算子(参考等式 1。15 。

)

其中指数中的 0.01 以 2 为基数。换句话说，0.01 = 2^—2。R_θ的倒数由下式给出

)

(5.21)

因此，对于 p ₂ = 1，我们考虑应用一个R_θ^—1的效果。

)

)

(5.22)

现在，如果我们将阿达玛门应用于等式 5.22 的结果，那么我们可以确定 p ₁ 。如果 p ₂ = 1 或 p ₂ = 0 是决定我们是在对第二个量子位应用R_θ^-1变换之后还是之前应用哈达玛门的因素。在我们将阿达玛门应用于第一个量子位之后，第一个量子位的状态是∣p2⟩.

可以推广相位估计的方法。对于一个和两个量子位输入所采取的相同步骤可以用于 p ₃ 、 p ₄ …并且有条件地旋转 p ₃ 、 p ₄ …对于 n 量子位上的模拟电路，估计形式为 ω = 0 的相位。p₁p₂p₃…，电路的输出由∣p_n…p₂p₁⟩.给出添加一些门来颠倒量子位的顺序给了我们一个有效的电路，它实现了

)

(5.23)

如果我们以相反的顺序在逻辑上标记方程 5.23 中的量子位，那么我们得到

)

(5.24)

等式 5.24 是通过反向应用相位估计电路实现的酉变换。“反向”应用电路意味着用它的反向门替换每个门，并以相反的顺序运行电路。方程 5.24 类似于科学和工程中广泛使用的经典离散傅立叶变换 (DFT)(见附录 A)。DFT 将向量 X 作为大小为 N 的输入，并输出向量 Y = WX ，其中 W 是傅立叶矩阵。QFT 被定义为使用 DFT 值确定的两个量子态之间的变换。如果X= {X_I}和Y= {Y_I}是向量使得 Y = WX ，那么 QFT 被定义为变换。

相位估计程序使用 QFT。QFT 可以被解释为相位估计操作的逆操作，并且向后应用相位估计电路给出了用于执行 QFT 的有效电路。

一个经典的 DFT 过程通过下面的变换将一个实向量)映射到另一个向量)在O(n2ⁿ)步骤中，其中)是跨越{1…2 ^{* n *} 的一组实数。

)

其中 k = 1，2，3…2^n。

QFT 将振幅对φ_{k编码的量子态映射到振幅对 y k 编码的量子态。}

)

(5.25)

其中)，在 O (2 ^{* n *} 步骤中。

方程 5.25 中的 j 上的和由于量子傅立叶变换应用于仅处于一个计算基态的状态而消失。基态∣ j ⟩对应经典情况，其中一个 φ _j 不为零，其余为零。

图 5-13 显示了用 Quirk [6]生产的八量子位 QFT 电路的电路表示。

图 5-13

八量子位量子傅里叶变换电路(用 Quirk [6]制作)

等式 5.25 的运算要求)量子位获得二进制串的第一个 b 位，以概率 1ε编码本征态。在量子相位估计过程中使用 QFT 的逆过程。

为了获得 ω 的估计，经由相位估计技术，使用酉 QFT )的逆，其中 U _{* f} 是量子傅立叶变换。基于状态∣0⟩、∣ 1⟩、…∣m*1⟩应用的逆 QFT 状态由下式给出

)

(5.26)

综上所述，给定一个酉门 U ，则 U 的一个特征向量∣ψ??n⟩由u|ψ|_n⟩=λ|ψ_n⟩.给出目的是找到特征值 λ 的近似值(或估计值)。由于 U 是酉的，所以 λ 的大小一定是 1，我们可以设λ=e^2πIω，其中 ω ∈ {0，1}和 ω = 0。p₁p₂p₃…高达 n 位的精度。目的是找到相位 ω 的估计值。

然后，通过以下步骤给出相位估计算法。

1. 用| 0_{n⟩|ψ⟩.发起}

2. 对第一个 n 个量子位应用h^{⊗n??【⊗】I 得到n= 2n从而得到。}

3. 根据第一个寄存器给定的次数，将 U 应用于第二个寄存器。换句话说，套用 map |k⟩|ψ⟩→|k⟩u^k|ψ⟩=e^{2πIωk|k⟩|ψ⟩.经过这一步，第一个 n 个量子位处于状态，其中 U _{* f} 为傅里叶变换。因此，傅立叶逆变换以概率 1 提供了∣2nω⟩=∣p*₁…p₂⟩。}

4. 对第一个寄存器应用傅里叶逆变换并测量结果。

如果 ψ 不能精确地以 n 位的精度写入，则可以表明该过程仍然能够以高概率提供对 ψ 的良好的 n 位近似。

用 Rigetti 森林进行量子编程

ri getti Computing²是一家总部位于加州伯克利的量子计算机制造商，由他们自己的超导量子处理器提供动力。该公司还开发了一个名为量子云服务(QCS)的云平台，通过该平台，他们的机器可以集成到任何公共、私有或混合云。Rigetti 的计算环境由一个名为 Forest 的 SDK 提供支持，这是一个用于量子/经典计算的全栈编程和执行环境。

森林可以开发量子/经典混合计算的算法，并了解量子计算机和算法的工作原理。可以使用运行在云中的量子虚拟机或 QVM 在量子位上模拟这些算法。还可以使用执行活动量子系统的简单函数调用与真实量子芯片进行交互。

以下是一些你应该知道的术语(也参见 Rigetti [61]的文档)。

• pyQuil :帮助编写和运行量子程序的开源 Python 库。源代码托管在 GitHub 的 http://github.com/rigetti/pyquil 。

• Quil :量子指令语言标准。用 Quil 编写的指令可以在量子抽象机(QAM)的任何实现上执行，如量子虚拟机(QVM)或真实的量子处理单元(QPU)。关于 Quil 的更多细节可以在白皮书“实用量子指令集架构”[71]中找到。

• QVM :量子虚拟机是量子抽象机在经典硬件上的开源实现。QVM 可以让你用一台普通的计算机模拟一台小型量子计算机，并执行 Quil 程序。QVM 可以在 GitHub 的 https://github.com/rigetti/qvm 找到，可以在标准笔记本电脑上运行。我们用 QVM 做下一个练习。

• QPU : 量子处理器。这是指可以运行量子程序的物理硬件芯片。

• Quil 编译器:编译器 quilc 将为一个 QAM 编写的 Quil 编译成另一个 QAM。根据其支持的指令集体系结构，我们的开源编译器采用任意的 Quil 并为给定的 QAM 编译它。在 https://github.com/rigetti/quilc 的 GitHub 上找到 quilc。

• Forest SDK : Rigetti 的软件开发套件，针对作为协处理器运行的近期量子计算机进行了优化，与传统处理器协同工作，运行混合量子经典算法。关于近期量子计算机可解决问题的参考，参见“NISQ 时代及以后的量子计算”[68]。

Forest SDK 是一个全面的语言套件，允许定义电路的能力，提供模拟器，收集量子算法，以及其他重要的组件。有关在各种操作系统上设置它的信息，请参考位于https://pyquil-docs.rigetti.com/en/stable/【61】的森林文档。下面是 Ubuntu Linux 18.04 LTS 版的设置概要。建议 Linux 环境中的所有工作都在虚拟环境中完成。

安装 QVM

为了充分利用 Rigetti Forest SDK，我们需要 pyQuil、QVM 和 Quil 编译器。在写这本书的时候，pyQuil 2.0 是 Rigetti 的库，用于在 Rigetti Forest 平台上生成和执行 Quil 程序。在安装之前，建议激活 Python 3.6+虚拟环境。然后，使用pip安装 pyQuil(对于 Ubuntu，您可能需要sudo命令)。

$ pip install pyquil

或者

$ sudo pip install pyquil

对于任何现有的 pyQuil 环境，运行升级总是好的。

pip install --upgrade pyquil

在下一步中，需要如下下载 QVM 和 Quil 编译器。

Forest 2.0 可下载 SDK 预览版包含以下内容。

• Rigetti 量子虚拟机(qvm)允许 Quil 程序的高性能模拟

• Rigetti Quil 编译器(quilc)允许将 Quil 程序编译和优化到本机门集

QVM 和编译器打包成程序二进制文件，可以通过命令行访问。两者都支持直接的命令行交互，以及一个服务器模式。使用 pyQuil 时，服务器模式是必需的。

森林 SDK 可以在 https://qcs.rigetti.com/sdk-downloads 下载。同一个下载站点提供了 Windows、macOS、Linux(.deb)、Linux(。rpm)和 Linux(裸机)。

在 Linux 上安装 QVM 和编译器

1. 通过点击 SDK 下载页面上适当的链接来下载发行版(对于 Ubuntu，下载 Debian 的包)。https://qcs.rigetti.com/sdk-downloads

2. 解压缩tarball并切换到该目录。

   tar -xf forest-sdk-linux-deb.tar.bz2
   cd forest-sdk-2.0rc2-linux-deb
   
   

3. 从同一个目录中，运行以下命令。

图 5-14

在虚拟环境中启动 QVM 服务器

1. 成功安装后，您应该能够运行以下两个命令。

   qvm --version
   quilc --version
   
   

2. SDK 安装成功后，打开一个终端窗口，切换到安装 SDK 的同一个虚拟环境，用qvm -S命令.在服务器模式下启动 QVM，这应该会启动 QVM 服务器，如图 5-14 所示，这里的虚拟环境称为qml。

sudo ./forest-sdk-2.0rc2-linux-deb.run

图 5-15

在虚拟环境中启动 Quilc 服务器

1. 保持 QVM 的终端运行，打开一个新的终端，切换到同一个虚拟环境，用quilc -S命令在服务器模式下启动 Quilc。

   quilc -S运行在qml虚拟环境中如图 5-15 所示。

2. 若要卸载林 SDK，请输入以下内容。

sudo apt remove forest-sdk

此时，你应该至少有两个终端窗口在后台打开并运行:一个用于qvm，一个用于quilc。

如果在同一个虚拟环境中没有安装 Jupyter notebook 或其他 Python 库，请使用下面的命令。

$ python3 -m pip install -U jupyter matplotlib numpy pandas scipy scikit-learn

下一步是启动 Jupyter 笔记本。打开一个新的第三终端窗口，切换到同一个虚拟环境，通过键入以下命令启动 Jupyter notebook。

$ jupyter notebook

这将在您的浏览器中打开一个 Jupyter 笔记本会话。保持此终端窗口打开。所以，在这个过程的最后，三个不同的终端窗口从同一个虚拟环境中运行:一个用于qvm，一个用于quilc,，一个用于 Jupyter notebook。

图 5-16

QVM、Quilc 和 Jupyter 笔记本电脑在同一个虚拟环境中运行

QVM、Quilc 和 Jupyter 笔记本终端的最终状态应该类似于图 5-16 所示的屏幕截图。

pyQuil [72]提供了一个函数来确保本地qvm和quilc当前正在环境中运行。为了确保两者都可用，我们需要执行from pyquil.api import local_forest_runtime，然后使用local_forest_runtime()。这将使用子流程启动qvm和quilc实例，如果它们还没有启动的话，如清单 5-2 所示。

from pyquil import get_qc, Program
from pyquil.gates import CNOT, Z
from pyquil.api import local_forest_runtime

prog = Program(Z(0), CNOT(0, 1))

with local_forest_runtime():
    qvm = get_qc('9q-square-qvm')
    results = qvm.run_and_measure(prog, trials=10)

Listing 5-2pyQuil Code to Verify qvm and quilc Are Available

对象允许我们构建一个 Quil 程序。get_qc()将我们连接到一个QuantumComputer对象，它指定了我们的程序应该在什么对象上运行(参见 https://pyquil-docs.rigetti.com/en/stable/qvm.html#qvm )。()从pyquil.gates模块导入所有*门，这允许我们向程序添加操作。

清单 5-3a 给出了使用 QVM 在 pyQuil 中引入一些操作的代码，并构建了一个三量子位量子傅立叶变换 (QFT)的描述。最初，我们导入一些库，并验证从 Jupyter 笔记本可以访问 QVM 和 Quilc 服务器。如果这一步没有出现任何错误，那么我们就可以开始了。

from pyquil import Program, get_qc
from pyquil.gates import *
import cmath
import matplotlib.pyplot as plt
import numpy as np
from pyquil.api import ForestConnection
from pyquil.api import WavefunctionSimulator
from pyquil.api import QVMConnection
from qutip import Bloch
from tempfile import mkdtemp
qvm = QVMConnection()

# Verify QVM and Quilc are available

from pyquil import get_qc, Program
from pyquil.gates import CNOT, Z
from pyquil.api import local_forest_runtime

prog = Program(Z(0), CNOT(0, 1))

with local_forest_runtime():
    qvm = get_qc('9q-square-qvm')
    results = qvm.run_and_measure(prog, trials=10)

Listing 5-3aLibraries for Quantum Fourier Transform (QFT) qft_forest.ipynb

对于第一个测试，让我们生成一个状态。

# Test
qvm = QVMConnection()
hello_qubit = Program()
print(qvm.wavefunction(hello_qubit))

Listing 5-3bLibraries for Quantum Fourier Transform (QFT) qft_forest.ipynb

这给出了以下输出。

作为第二个测试，让我们首先构建一个响铃状态并运行程序。量子位 0 被初始化为具有哈达玛 H 门的叠加态。然后用 CNOT 门在量子位 0 和 1 之间产生一个纠缠态。然后运行程序。

# construct a Bell State program
p = Program(H(0), CNOT(0, 1))
# run the program on a QVM
qc = get_qc('9q-square-qvm')
result = qc.run_and_measure(p, trials=10)
print(result[0])
print(result[1])

Listing 5-3cTest with Bell State qft_forest.ipynb

贝尔状态的代码给出了以下输出。

QC是模拟量子计算机。run_and_measure告诉 QVM 运行程序，执行一个测量来压缩状态，并返回结果。trials是指程序运行的次数。

对run_and_measure的调用向已经启动的两个服务器(qvm和quilc)发出请求。调用 Quilc 服务器实例将 Quil 程序编译成本机 Quil，调用 QVM 服务器实例模拟并返回程序十次测量结果。如果您打开运行您的服务器的终端窗口，您应该看到输出打印到控制台关于我们提出的请求。

下一步，做量子傅立叶变换。任务是将 QFT 应用于对应于我们想要计算 DFT(离散傅立叶变换)的序列的状态的幅度。为此，我们需要三个量子位来转换一个 8 位序列。

需要计算的序列是 01000000，所以初始状态是|001⟩.对于具有多于一个 1 的位串，需要所有选定状态的相等叠加；例如，01100000 是|001⟩和|010⟩.的等量叠加一个 x 门应用于第零个量子位建立了|001⟩态。可以通过用Wavefunction Simulator计算其波函数来验证这一点。我们需要添加一些“虚拟”量子位，否则，波函数将只为量子位 0 返回一个二元向量。这显示在清单 5-3d 中。

# Quantum Fourier Transform

state_prep = Program(X(0))
qft = Program()
qft += H(0)
qft += CPHASE(π/2, 1, 0)
qft += H(1)
qft += CPHASE(π/4, 2, 0)
qft += CPHASE(π/2, 2, 1)
qft += H(2);

# Add dummy qubits
from pyquil.api import WavefunctionSimulator
add_dummy_qubits = Program(I(1), I(2))  # The identity gate I has no affect
wf_sim = WavefunctionSimulator()
wavefunction = wf_sim.wavefunction(state_prep + add_dummy_qubits)
print(wavefunction)

Listing 5-3dState Preparation for Quantum Fourier Transform (QFT) qft_forest.ipynb

这给出了以下输出。

接下来，它被定义为一个函数 qft1，来制作一个三量子比特的 qft 量子程序。该算法在本章前面已有描述。该实现由 Hadamard 和 CPHASE 门组成，并带有一个用于位反转校正的交换门。qft1函数不计算 QFT，而是制作一个量子程序来计算量子位q0, q1,和q2的 QFT。

# 3 qubit QFT Program: DFT of [0, 1, 0, 0, 0, 0, 0, 0], using pyQuil:
from math import pi

def qft1(q0, q1, q2):
    p = Program()
    p += [SWAP(q0, q2),
          H(q0),
          CPHASE(-pi / 2.0, q0, q1),
          H(q1),
          CPHASE(-pi / 4.0, q0, q2),
          CPHASE(-pi / 2.0, q1, q2),
          H(q2)]
    return p

print(qft1(0, 1, 2))

Listing 5-3eState Preparation for QFT qft_forest.ipynb

代码片段将以下内容作为输出返回。

接下来，我们运行 QFT。

compute_qft_prog = state_prep + qft1(0, 1, 2)
wavefunction = wf_sim.wavefunction(compute_qft_prog)
print(wavefunction.amplitudes)

Listing 5-3fExecute Quantum Fourier Transform (QFT) qft_forest.ipynb

这将返回以下输出。

在最后一步中，我们运行清单 5-3g 来验证使用快速傅立叶逆变换(FFT)的 QFT 运行。

# Verify qft by inverse FFT

from numpy.fft import ifft
ifft(wavefunction.amplitudes, norm="ortho")

Listing 5-3gVerify QFT with Inverse FFT qft_forest.ipynb

如果我们忽略 1e-17 级的项，就会产生下面的数组作为输出，给出[0，1，0，0，0，0，0，0]，这是我们的输入。

展望未来，我们将使用更多来自 Rigetti Forest 的示例，尤其是当我们在未来章节中查看变分算法(如 Max-Cut)时。

测量和混合状态

测量在第一章中进行了说明。本节从动手编程的角度来看这个问题。测量是量子力学中的一个核心概念。考虑它的一种方式是作为一个概率分布的样本。作为一个有很多结果的随机变量，每个结果都是以一定的概率产生的。除非对系统进行测量，否则它会保持叠加态，因为一般来说，测量行为会破坏量子态。

测量是量子系统和我们现有的经典世界之间的核心联系。自然界中的量子态不能被直接观察到——只有在对它们的状态进行测量后，才能记录下关于它的统计数据。除了量子世界和经典世界之间明显的界限之外，还有一个微妙的现实:一个量子系统与其周围的环境相互作用，除非它完全和完美地与之隔离。这种相互作用导致混合态的存在。在一定限度内，混合态恢复经典概率，给出量子态的解释。量子测量是通过让一个封闭的量子系统以一种受控的方式与一个外部系统相互作用来完成的，从该外部系统可以恢复量子系统的测量状态。

在量子力学中，测量状态的基本原理包括 bra 和 ket 。作为一个提醒，一个胸罩被⟨ψ|命名为某种量子态∣ ψ ⟩.他们一起形成了 bra-ket 或狄拉克符号。一个胸罩是一个胸罩的共轭转置，反之亦然。这也意味着胸罩是一个行向量。Qiskit 中的代码如本书代码库中的清单 5-4a 所示。

import numpy as np
zero_ket = np.array([[1], [0]])
print("|0> ket:\n", zero_ket)
print("<0| bra:\n", zero_ket.T.conj())

Listing 5-4aBra and Ket in Qiskit MeasMixedSt_qiskit.ipynb

这给出了以下输出。

我们也可以尝试胸罩和胸衣，这是一个矩阵；本质上，两个向量的外积:|0⟩⟨0|，如代码清单 5-4b 所示。

zero_ket.dot(zero_ket.T.conj())

Listing 5-4bBra and Ket in qiskit MeasMixedSt_qiskit.ipynb

这进而给出了一个矩阵数组作为输出。

这个输出看起来很熟悉，因为它是规范基的第一个元素的投影(见第一章)。总的来说，|𝜓⟩⟨𝜓|将成为|𝜓⟩.的投影仪如果我们取一些其他的量子态|𝜙⟩，并对其应用|𝜓⟩⟨𝜓|矩阵，我们得到|𝜓⟩⟨𝜓|𝜙⟩.最右边的两个术语是 bra 和 ket，这表明它是点积，是|𝜙⟩和|𝜓⟩.之间的重叠由于这是一个标量，它缩放最左边的项，即 ket |𝜓⟩，所以实际上，|𝜙⟩投影到了这个向量上。

量子力学中的测量通常会产生一个由算符驱动的随机变量。测量理论是一个丰富而活跃的研究领域，这意味着仍有许多未知和问题有待回答。然而，我们今天拥有的大多数量子计算机只实现了一个非常特定的测量，这使得事情简单了很多。这种测量是在规范的基础上进行的。换句话说，测量包含两个投影，|0⟩⟨0|和|1⟩⟨1|，这种测量可以应用于量子计算机的任何量子位。

第一章解释了如何在矢量上应用投影。为了得到标量值，我们需要在左边添加一个胸罩。例如，对于|𝜓⟩，我们得到⟨𝜓|0⟩⟨0|𝜓⟩.的标量这被称为操作者|0⟩⟨0|.的期望值

为了将理论放在上下文中，可以在叠加态)上进行投影|0⟩⟨0|，即哈达玛变换，其可以表示为列向量)。这显示在清单 5-4c 中。

ψ = np.array([[1], [1]])/np.sqrt(2)
Π_0 = zero_ket.dot(zero_ket.T.conj())
ψ.T.conj().dot(Π_0.dot(ψ))

Listing 5-4cProjection MeasMixedSt_qiskit.ipynb

它给出了以下输出

那正好是叠加态|0⟩对应的概率振幅的绝对值的平方的一半。下面是第一章中一个索赔的数学形式:给定一个状态|ψ⟩=α₀|0⟩+α₁|1⟩，我们以概率|α_{I|²， 这是天生法则的一种体现。玻恩规则提供了量子理论的数学形式和实验之间的联系。因此，它是与几乎所有量子物理预言相关的最重要的理论之一。在科学史上，与海森堡的测不准关系一样，玻恩法则通常被视为非决定论进入基础物理学的转折点。这正是量子模拟器中实现的内容。这里描述的是模拟器中的测量。}

对于与哈达玛门的相等叠加(使用 Jupyter 笔记本中的量子电路章节 4 ，我们需要应用测量并观察统计，如清单 5-4d 所示。

from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute
from qiskit import BasicAer
from qiskit.tools.visualization import plot_histogram
backend = BasicAer.get_backend('qasm_simulator')
q = QuantumRegister(1)
c = ClassicalRegister(1)
circuit = QuantumCircuit(q, c)
circuit.h(q[0])
circuit.measure(q, c)
job = execute(circuit, backend, shots=100)
plot_histogram(job.result().get_counts(circuit))

Listing 5-4dMeasurment Statistics MeasMixedSt_qiskit.ipynb

输出显示在图 5-17a 的柱状图中。如果是运行几次，那就是一个随机输出。图 5-17b 是清单 5-4d 第二次运行的示例。

图 5-17b

测量统计数据输出的随机性

图 5-17a

测量统计的输出

输出显示，大约一半的结果约为 0。然而，即使测量有一个随机的结果，一旦它被执行，量子态就在相应的基矢中。即叠加被破坏。这被称为波函数的坍缩。测量的这一性质是许多正在进行的辩论和研究结果的主题，关于它如何发生以及为什么发生，但重要的是，我们可以在测量后很容易地“计算”相应量子态的状态。然而，将状态投影到基向量是不够的，因为它不会被规范化，所以我们必须将其重新规范化。

例如，如果我们在测量叠加)后观察到零，测量后的状态在清单 5-4e 中给出。

ψ = np.array([[np.sqrt(2)/2], [np.sqrt(2)/2]])
Π_0 = zero_ket.dot(zero_ket.T.conj())
probability_0 = ψ.T.conj().dot(Π_0.dot(ψ))
Π_0.dot(ψ)/np.sqrt(probability_0)

Listing 5-4eMeasurment Statistics MeasMixedSt_qiskit.ipynb

它有以下输出。

简单地说，我们得到一个由列向量)给出的|0⟩。将两个测量值按顺序放在同一个量子位上，就可以看到结果。第一次测量是随机的，但是第二次测量是确定的，因为在第一次测量之后在计算基础上没有叠加。因此，第二次测量总是给出与第一次相同的结果。下面是我们 Jupyter 笔记本的清单 5-4f 中对此的模拟。我们通过将两次测量的结果写入两个不同的经典寄存器来创建它。

c = ClassicalRegister(2)
circuit = QuantumCircuit(q, c)
circuit.h(q[0])
circuit.measure(q[0], c[0])
circuit.measure(q[0], c[1])
job = execute(circuit, backend, shots=100)
job.result().get_counts(circuit)

Listing 5-4fMeasurment Statistics MeasMixedSt_qiskit.ipynb

下面显示了输出。

可以看到，没有 01 或 10 之类的输出。

现在你已经看到了单量子位中的测量行为，测量多量子位系统是有帮助的。大多数量子计算机实现的是局部测量，也就是说每个量子比特都是单独测量的。因此，如果我们有一个两量子位系统，其中第一个量子位处于相等的叠加态，第二个处于|0⟩态，也就是说，我们有状态)，我们观察到“0 和 0”或“0 和 1”作为两个量子位的测量结果。

q = QuantumRegister(2)
c = ClassicalRegister(2)
circuit = QuantumCircuit(q, c)
circuit.h(q[0])
circuit.measure(q, c)
job = execute(circuit, backend, shots=100)
plot_histogram(job.result().get_counts(circuit))

Listing 5-4gMeasurment of Multi-Qubit Systems MeasMixedSt_qiskit.ipynb

这将直方图作为统计输出，如图 5-18 所示。

图 5-18

多量子比特系统的测量统计

接下来，让我们对一个纠缠态进行测量，并获得 100 次这样的测量后的统计量。

q = QuantumRegister(2)
c = ClassicalRegister(2)
circuit = QuantumCircuit(q, c)
circuit.h(q[0])
circuit.cx(q[0], q[1])
circuit.measure(q, c)
job = execute(circuit, backend, shots=100)
plot_histogram(job.result().get_counts(circuit))

Listing 5-4hMeasurement of Entangled State MeasMixedSt_qiskit.ipynb

列表 5-4h 给出了图 5-19 所示的直方图作为统计输出。

图 5-19

纠缠系统的测量统计

作为输出，我们只观察 00 和 11。既然状态是)，这应该不足为奇。然而，这里发生了一些不寻常的事情。在最后一段代码的末尾，有相同的统计数据，但是在相同的量子位上有个测量值。我们有两个空间分离的量子位表现出相同的行为，这是一种非常强的关联形式*。这意味着，如果我们测量一个量子位并得到比如说 0 的结果，我们肯定知道如果我们测量另一个量子位，我们也会得到 0，即使第二次测量*也是一个随机变量。**

为了更好地理解这一点，想象我们正在投掷两枚无偏的硬币。如果我们观察其中一个的正面，除了一个概率为 0.5 的预测外，我们完全无法知道另一个可能是什么。如果我们使用有偏见的硬币，那么我们可能会提高我们的预测准确性。然而，我们仍然不能根据我们在一枚硬币上观察到的结果来肯定地说另一枚硬币是什么。

尽管纠缠现象与两个量子位之间的物理距离无关，甚至可以跨越光年的宇宙距离，但纠缠量子位之间不存在激活或瞬时“超过光速”信号。*测量对于量子位是局部的，*信息也是局部的。如果其他人正在测量另一个量子位，我们必须通过经典的通信渠道告诉这个人，我们碰巧知道结果会是什么。因此，虽然我们肯定不能用纠缠来违反相对论，但这种强关联形式仍然是许多量子算法的核心。

混合状态

混合状态在第一章中进行了阐述。一个密度矩阵是另一种写量子态的方式，而不是 kets。正如我们已经看到的，胸乳是一种投射。但是它们也可以形成密度矩阵。例如，我们可以写𝜌=|𝜓⟩⟨𝜓|，𝜌是|𝜓⟩.的密度矩阵玻恩法则仍然适用，但是现在结果的轨迹变得重要了。例如， Tr [|0⟩⟨0| ρ |]将是看到 0 的概率。清单 5-4i 是这样的代码。

ψ = np.array([[1], [1]])/np.sqrt(2)
ρ = ψ.dot(ψ.T.conj())
Π_0 = zero_ket.dot(zero_ket.T.conj())
np.trace(Π_0.dot(ρ))

Listing 5-4iTrace in Mixed States MeasMixedSt_qiskit.ipynb

这给出了输出

换句话说，再拿一半。测量后的重正化类似地发生，如下所示。

)

这显示在清单 5-4j 中。

probability_0 = np.trace(Π_0.dot(ρ))
Π_0.dot(ρ).dot(Π_0)/probability_0

Listing 5-4jRenormalization MeasMixedSt_qiskit.ipynb

随着输出

尽管每个状态都被创建为 ket 和 bra，但还有其他被称为混合状态的状态:纯状态上的经典概率分布。形式上，一个混合状态写成∑ρ_I∣ψ_I⟩⟨ψ_I∣，其中∑ρ**I= 1， ρ _{我们可以举个例子，比较一下相等叠加态和混合态 0.5( ∣ 0⟩⟨0| + | 1⟩⟨1 ∣)的密度矩阵，如清单 5-4k 所示。}

zero_ket = np.array([[1], [0]])
one_ket = np.array([[0], [1]])
ψ = (zero_ket + one_ket)/np.sqrt(2)
print("Density matrix of the equal superposition")
print(ψ.dot(ψ.T.conj()))
print("Density matrix of the equally mixed state of |0><0| and |1><1|")
print((zero_ket.dot(zero_ket.T.conj())+one_ket.dot(one_ket.T.conj()))/2)

Listing 5-4kMixed State MeasMixedSt_qiskit.ipynb

输出如下。

被称为相干的非对角元素在第二种情况下消失了。相干性的存在表明状态是量子的。这些值越小，量子态就越接近经典的概率分布。

第二密度矩阵只有个对角元素，且相等；这是一个均匀分布的等价写法。均匀分布具有最大熵，因此，具有这种结构的密度矩阵称为最大混合态。换句话说，我们完全不知道规范基的哪些元素构成了状态。

理想情况下，量子态应该与环境完全隔绝。然而，在现实中，量子计算机还不能实现高度的隔离。因此，相干性慢慢地消失在环境中。这个过程叫做消相干。退相干发生的速度决定了我们可以在量子计算机上运行的量子算法的长度:如果它发生得很快，我们就有时间应用一些门或进行任何其他形式的计算，并快速测量结果。

密度矩阵比状态向量更有表现力，因为状态向量只能表示纯状态。但是，即使是一个处于混合状态的系统，它也可以被看作是一个处于纯状态的更大系统的一部分。这个将放大系统的混合态转化为纯态的过程叫做净化。一个 n 量子位系统的混合状态可以通过添加更多的 n 量子位并与 2 n 量子位系统一起工作来提纯。一旦纯化，2 个 n 个量子位的联合系统处于纯态，而第一个 n 个量子位仍处于原始混合态。

开放和封闭量子系统

让我们从列出你已经获得的封闭量子系统的见解开始。

• 封闭系统是基本的，任何考虑中的系统都表示为封闭系统。

• 在标准量子力学中，人们考虑封闭系统(即，与环境完全隔离的系统)。由此产生的动力是单一的。

• 这是一种理想化，因为物理系统不可能与它们的环境完全隔离(也许与整个宇宙隔离)。

在封闭的量子系统中，系统的动力学完全独立于环境的动力学。因此，在这个系统产生时与它相关的可观察量，例如，它的总能量，在系统演化期间保持不变。这样的系统，虽然便于获得洞察力和理解，但远远不现实。图 5-20 显示了封闭量子系统的图示。

图 5-20

封闭量子系统

然而，由于每个量子系统都与它的环境相互作用，遵守完美幺正量子动力学的孤立、封闭量子系统的理想化是一种理想化。事实上，每个系统都是开放的，这意味着它与外部环境相耦合。图 5-21 展示了一个开放的量子系统。

图 5-21

开放量子系统

开放量子系统理论是几乎所有现代量子力学及其应用研究的基础。有时，这些开放系统的影响很小，但它们很难被忽略。这在量子信息处理领域中特别相关，在该领域中，相对于经典信息处理的量子优势的存在通常首先来自理想化的封闭系统观点，然后必须在现实的开放系统环境中重新审视。有了这些想法，我们开始考虑以下观点来研究开放系统。

• 开放系统是基础，任何考虑中的系统都表示为开放系统。

• 感兴趣的系统与外部环境相互作用的事实对于我们描述该系统是至关重要的。

当我们在混合环境中单独观察子系统 A 时，两体系统的纯态可能表现得像混合态。如果我们只想知道 A 的动力学呢？即使我们不完全了解子系统 B，我们能描述它的演化吗？如果我们假设二体系统的状态经历幺正演化，我们如何单独描述 A？

封闭系统和开放系统之间的区别在于将系统与环境分开的边界的假定特征。对于封闭系统，边界是不可渗透的(即，系统和环境之间不允许信息流，从而使系统能够孤立地发展)。因此，完整的哈密顿量描述了系统本身的动力学。

在开放的量子系统中，边界不再是不可渗透的，因此，系统可以自由地与其环境交换信息，无论是相位还是能量。因此，没有一个框架来确保可观测的量在系统的演化过程中保持守恒。一个开放的系统比一个封闭的系统更接近真实的场景。因此，宇宙中包含的任何东西(即宇宙的任何子系统都必须是开放系统)。任何被认为是封闭系统的系统都只是一种近似。

量子态演化，其演化由酉矩阵描述。这导致了量子计算中一些有趣的性质。酉进化对于一个封闭的系统是真实的；也就是一个与环境完美隔绝的量子系统。我们今天拥有的量子计算机却不是这样，它们是开放的量子系统，由于与环境的不可控相互作用而发生不同的进化。在本节中，我们将通过一些 Jupyter 笔记本示例来深入了解这一过程。对开放量子系统和相关动力学的深入理论讨论超出了本书的范围。我推荐 Rivas 和 Huelga 的书[62]和麻省理工学院开放课件[63]。

在这本笔记本中，我们对这两种类型的进化都有所了解。如果一个算子与它自己的伴随算子相乘时产生一个单位矩阵作为输出，则该算子被认为是酉的。酉算子有一个与其共轭算子相等的逆算子。算子 U 的逆用U1 表示。这满足以下关系。

)

其中 I 是恒等运算符。

为了使 U 成为一体，

)

和

)

“非”运算是由量子计算机中的 X 门执行的。虽然关于门的一般性讨论只出现在后续的笔记本中，但是我们可以研究 X 门的属性。它的矩阵表示是)。Jupyter 笔记本代码ClosedOpenSystems.ipynb的清单 5-5a 验证它是否确实是酉的。

import numpy as np
X = np.array([[0, 1], [1, 0]])
print("XX^dagger")
print(X.dot(X.T.conj()))
print("X^daggerX")
print(X.T.conj().dot(X))

Listing 5-5aEvolution of Unitary Gates ClosedOpenSystems.ipynb

清单 5-5a 给出以下输出。

因此， X 看起来是一个合法的酉运算。单一性确保了1₂范数得以保留；也就是说，量子态被映射到量子态。清单 5-5b 显示了寻找范式演变的代码。

print("The norm of the state |0> before X is applied")
zero_ket = np.array([[1], [0]])
print(np.linalg.norm(zero_ket))
print("The norm of the state after X is applied")
print(np.linalg.norm(X.dot(zero_ket)))

Listing 5-5bEvolution of Norm ClosedOpenSystems.ipynb

以下输出确认了规范得到了保留。

由于酉运算是矩阵，所以线性。测量值也用矩阵表示。这两个观察暗示量子计算机实现的一切都是线性的。如果某种形式的非线性是期望的，那么这必须涉及一些经典的干预。

酉运算的另一个结果是可逆性(即，任何酉运算都可以反转)。因此，量子计算库通常提供逆转整个电路的功能。由于 X 门是自身的共轭转置，因此需要再次应用该门进行反转，这意味着X2= 1。

import numpy as np
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute
from qiskit import BasicAer
from qiskit.tools.visualization import circuit_drawer
np.set_printoptions(precision=3, suppress=True)
backend_statevector = BasicAer.get_backend('statevector_simulator')
q = QuantumRegister(1)
c = ClassicalRegister(1)
circuit = QuantumCircuit(q, c)
circuit.x(q[0])
circuit.x(q[0])
job = execute(circuit, backend_statevector)
print(job.result().get_statevector(circuit))

Listing 5-5cEvolution of norm ClosedOpenSystems.ipynb

输出是

这和预期的完全一样是 0。

正如我们之前强调的，真实的量子系统很少是封闭的。他们不断地以一种非常困难的方式与他们的环境进行交互，以今天的技术水平来看，有时是不可能控制的，这反过来又会导致他们失去连贯性。对于当前和近期的量子计算机来说也是如此。这意味着它们的实际时间演化不是由一个酉矩阵描述的，而是由一个叫做完全 正轨迹保持映射的其他算子描述的。

量子计算库通常提供各种噪声模型来模拟和模仿不同类型的相互作用。增加与环境相互作用的强度会导致更快的消相干。退相干的时间尺度通常被称为T2 时间。在其他几个参数中， T ₂ 时间对于门的数量或我们可以执行的量子计算的持续时间至关重要。

研究退相干效应的一个简单方法是将一个纯态与最大混合态混合)，其中𝑑是量子比特的数量。这样，我们不必指定噪声模型或任何其他映射建模去相干。例如，我们可以混合|𝜙+⟩态和最大混合态。

def mixed_state(pure_state, visibility):
    density_matrix = pure_state.dot(pure_state.T.conj())
    maximally_mixed_state = np.eye(4)/2**2
    return visibility*density_matrix + (1-visibility)*maximally_mixed_state

φ = np.array([[1],[0],[0],[1]])/np.sqrt(2)
print("Maximum visibility is a pure state:")
print(mixed_state(φ, 1.0))
print("The state is still entangled with visibility 0.8:")
print(mixed_state(φ, 0.8))
print("Entanglement is lost by 0.6:")
print(mixed_state(φ, 0.6))
print("Hardly any coherence remains by 0.2:")
print(mixed_state(φ, 0.2))

Listing 5-5dMaximally Mixed State ClosedOpenSystems.ipynb

清单 5-5d 给出了以下输出。

在开放系统中观察量子态的一种方式是通过它的平衡过程。例如，一杯热气腾腾的茶由于与环境相互作用而失去热量，最终达到环境的温度。这个过程包括能量交换。量子态表现出同样的行为。

这个平衡态被称为热态 ，，它有一个非常特殊的结构，我们以后会再讨论它。取自热状态的统计样本的能量遵循波尔兹曼分布【64 】,由下式给出

)

其中p(ϵ_I)为状态 i 的概率。 ϵ _i 是状态 i 的能量。 k 是玻尔兹曼常数。 T 是系统的温度。M 是感兴趣系统可访问的所有状态的数量。 Q 是归一化分母。温度越高，我们就越接近均匀分布。在无限温度极限下，它恢复均匀分布。在高温下，所有能级的概率相等。相比之下，在零温度下，整个概率质量都集中在最低能级——基态能量。为了了解这个过程，清单 5-5e 绘制了不同温度下的玻尔兹曼分布。

import matplotlib.pyplot as plt
temperatures = [.5, 5, 2000]
energies = np.linspace(0, 20, 100)
fig, ax = plt.subplots()
for i, T in enumerate(temperatures):
    probabilities = np.exp(-energies/T)
    Z = probabilities.sum()
    probabilities /= Z
    ax.plot(energies, probabilities, linewidth=3, label = "$T_" + str(i+1)+"$")
ax.set_xlim(0, 20)
ax.set_ylim(0, 1.2*probabilities.max())
ax.set_xticks([])
ax.set_yticks([])
ax.set_xlabel('Energy')
ax.set_ylabel('Probability')
ax.legend()

Listing 5-5eBoltzmann Distribution ClosedOpenSystems.ipynb

这给出了图 5-22 中的图作为输出。

图 5-22

玻尔兹曼能量分布

该图显示 ?? < ?? < ??。?? 是低温，并且预期在低能级急剧达到峰值。相比之下，?? 是非常高的温度，概率分布几乎完全平坦。

这些练习旨在增加你对来自外部观察者的测量的影响如何触发在封闭系统中没有类似物的新型多体现象的理解。概括地说，孤立量子系统的时间演化由单个厄米算符(即哈密顿量)描述。相反，在连续观察下，由于测量反作用，动力学变得本质上非酉，并且不仅由哈密顿量表征，而且由测量过程表征。

量子主成分分析

机器学习和分析练习通常有许多特征，其中一些是相关的。例如，考虑房价，它是房子的许多特征的函数，例如卧室和浴室的数量、平方英尺、地段大小、建造日期和位置。通常，您希望将要素的数量限制为最重要的要素(即获取数据中最大方差的要素)。例如，如果有人只考虑特定街道上的房屋，那么位置可能并不重要，但面积可能会有很大的差异。

确定哪些特征捕捉到最大的方差被称为主成分分析 (PCA) [65]。数学上，PCA 涉及获取原始数据(例如，各种房屋的特征向量)并计算协方差矩阵。

参考文献[66]中提出的用于执行 qPCA(量子 PCA)的量子算法使用密度矩阵表示。这里讨论的算法有四个主要步骤。

1. 在量子密度矩阵 ρ 中编码协方差矩阵σ。

2. 准备多份 ρ 。

3. 对每个拷贝和一个目标系统执行指数交换操作。

4. 执行量子相位估计以确定特征值。

要在高噪声模拟器上实现这种 qPCA 算法，请参考参考文献[67]。作者还在 GitHub 的 https://github.com/rmlarose/vqsd 发布了 Cirq 中的代码。图 5-23 显示了在噪声量子模拟器上实现 qPCA 量子算法的步骤。作者称该算法为变分量子态对角化或 VQSD。

图 5-23

qPCA/VQSD 算法实现(来源[67])

下面解释 VQSD 算法的步骤，如图 5-23 所示。

(a)输入是量子态 ρ 的两个副本。这些状态被发送到参数优化循环，(b)其中混合量子经典变分算法(将在后面的章节中解释)近似对角化酉U_pα_opt。这里， p 是一个超参数，表示解决方案的质量。该最优酉被发送到特征值读出电路©以获得位串 z ，其频率提供了对 ρ 的特征值的估计。连同最优酉*_pα_opt，这些位串被送到本征向量准备电路，(d)在量子计算机上准备 ρ 的本征态。特征值和特征向量都是 VQSD 算法的输出。*

*## 摘要

这一章冒险进入量子算法的第一部分，从我们上一章结束的地方开始。它着眼于一些重要的算法和方法，如 Deutsch-Jozsa 算法，量子计算复杂性，编码技术(基础，张量积，振幅和哈密顿)，以及经典数据输入到量子算法的过程。我们也冒险进入测量和混合状态，量子傅立叶变换，和它的一个重要应用，即相位估计。我们首先查看了 Rigetti 的森林 SDK 和 QVM，并在其他练习中使用了 Qiskit 和 Cirq。下一章继续到先进的量子算法和相关的代码。

Footnotes 1

人们认为这种代码很难被经典计算机破解。例如，没有已知的经典算法能够在有效的时间内分解数字以破解 RSA 加密。

2

Aspen、Forest、Forest SDK、Pyquil、QCS、Quantum Advantage Prize、quil、Quilc、Quil-T、QVM 和 Rigetti 是 Rigetti & Co，Inc .的商标或注册商标。

*