1 Qiskit 实现

这段引言首先回顾了上一课的核心内容，为当前的学习内容设置了上下文。

1. 回顾：上一课介绍了 Qiskit 中的两个核心类：
   • Statevector：这个类用于在数学上精确表示一个量子态。对于单个量子比特，它是一个包含两个复数的向量，这两个复数分别代表量子比特处于 $\vert 0 \rangle$ 和 $\vert 1 \rangle$ 状态的概率幅。
   • Operator：这个类用于表示作用在量子态上的量子门或操作。对于单个量子比特，它是一个 2x2 的酉矩阵。
2. 点明上一课的范围：明确指出之前的学习内容局限于“单个量子比特”的系统。这是量子计算入门的典型起点，因为它最简单，便于理解基本概念，如叠加和相位。
3. 引出本节主题：清晰地声明本节的目标是“探索多个量子比特的行为”。这是从单个系统到多个系统（即量子寄存器）的自然延伸，也是量子计算能够展现其强大计算能力的关键所在。处理多个量子比特意味着我们需要引入新的数学工具和概念，例如张量积，来描述组合系统的状态和操作。

这是一个非常基础但很重要的代码单元，其目的是确认当前环境中安装的 Qiskit 库的版本。

• from qiskit import __version__: 这行代码从 Qiskit 库的根包中导入一个名为 __version__ 的特殊变量。在 Python 的包管理规范中，__version__ 是一个普遍使用的约定，用于存储库的当前版本号。
• print(__version__): 这行代码将导入的版本号变量打印输出到屏幕上。
• 2.1.1: 这是 print 函数执行后显示的结果。它告诉我们，运行这段代码的 Python 环境中，安装的 Qiskit 版本是 2.1.1。

这段文字和代码块是在为后续的量子模拟和计算做准备，通过导入必需的工具（类和函数）来搭建工作环境。

1. 说明文字:
   • 我们将首先导入 Statevector 和 Operator 类: 明确指出将要从 Qiskit 库中引入两个核心工具。这两个类是 qiskit.quantum_info 模块的一部分，该模块专注于处理和分析量子信息的底层数学对象。
   • 以及来自 NumPy 的平方根函数: 提到还需要一个数学辅助函数 sqrt (square root)。它来自 NumPy，一个强大的 Python 科学计算库。在量子计算中，经常需要对概率幅进行归一化，这通常涉及到开平方根操作（例如，一个量子态的概率幅平方和必须为1）。
   • 此后...首先处理所有必需的导入: 这句话建立了一个编程风格的约定。告诉读者，在本教程系列中，习惯将所有需要的库和模块在代码的开头一次性导入。这是一种清晰、规范的编程实践，能让人一目了然地知道当前代码依赖哪些外部工具。
2. 代码块:
   • from qiskit.quantum_info import Statevector, Operator: 这行是导入语句。
   • from qiskit.quantum_info: 指定要从哪个模块导入。qiskit.quantum_info 是 Qiskit 中专门用于进行量子信息理论计算和模拟的模块。
   • import Statevector, Operator: 列出要导入的具体对象。Statevector 是用于表示量子态矢量的类，而 Operator 是用于表示量子算符（门）的类。
   • from numpy import sqrt: 这行也是导入语句。
   • from numpy: 指定从 NumPy 库导入。
   • import sqrt: 明确导入 sqrt 函数。这样，在代码中就可以直接使用 sqrt(...)，而不需要写成 numpy.sqrt(...)。

这段话引入了描述多量子比特系统的核心数学运算——张量积 (tensor product)，并说明了如何在 Qiskit 的 Statevector 类中实现它。

1. 核心概念：张量积
   • 什么是张量积？在线性代数中，张量积（通常用符号 $\otimes$ 表示）是一种将两个向量空间（或向量）合并成一个更大、更复杂的向量空间（或向量）的方法。
   • 为什么量子计算需要它？当我们从单个量子比特（一个2维的希尔伯特空间 $\mathcal{H}_1$）扩展到两个量子比特时，这个双量子比特系统的联合状态并不存在于两个2维空间中，而是存在于一个由这两个空间张量积构成的新空间 $\mathcal{H}_2 = \mathcal{H}_1 \otimes \mathcal{H}_1$ 中。这个新空间的维度是 $2 \times 2 = 4$ 维。张量积是描述“组合系统”的数学语言。
2. Qiskit 中的实现
   • Statevector 类: 代表量子态矢量。
   • .tensor() 方法: 这是 Statevector 对象的一个内置函数（方法）。它的作用就是计算张量积。
   • 如何工作: 如果你有一个 Statevector 对象 sv1，你可以调用 sv2 = sv1.tensor(another_sv)。这个调用会计算 sv1 $\otimes$ another_sv，并返回一个新的 Statevector 对象 sv2，这个新对象就表示了组合系统的状态。
   • 顺序的重要性: 该参数被解释为右侧的张量因子。这句话强调了运算的顺序。sv1.tensor(sv2) 计算的是 sv1 $\otimes$ sv2。在量子计算中，量子比特的顺序（通常称为比特序或量子比特索引）很重要，因为它决定了基矢量的标签。例如，$\vert 0 \rangle \otimes \vert 1 \rangle$ 记作 $\vert 01 \rangle$，而 $\vert 1 \rangle \otimes \vert 0 \rangle$ 记作 $\vert 10 \rangle$，这是两个完全不同的状态。Qiskit 遵循的约定是，第一个操作数（调用 tensor 方法的对象）对应于组合系统中的“高位”或“左边”的量子比特，而参数则对应于“低位”或“右边”的量子比特。但请注意，Qiskit内部的比特编号是从右到左的，最右边是0号比特，这在后面会详细讲。

这段内容通过一个具体的代码示例，演示了如何使用 Statevector 类创建基本量子态并计算它们的张量积。

1. 创建基本态矢量:
   • zero = Statevector.from_label("0"): 这行代码创建了一个表示量子态 $\vert 0 \rangle$ 的 Statevector 对象。
   • Statevector.from_label(...) 是一个类方法（也叫静态方法），可以直接通过类名调用，而无需先创建类的实例。它提供了一种便捷的方式，通过使用预定义的标签字符串来生成标准量子态。
   • "0" 是一个标签，Qiskit 会自动将其识别为计算基态 $\vert 0 \rangle$，并生成对应的态矢量 $\begin{pmatrix} 1 \\ 0 \end{pmatrix}$。
   • one = Statevector.from_label("1"): 同理，这行代码使用标签 "1" 创建了表示量子态 $\vert 1 \rangle$ 的 Statevector 对象，其内部表示为向量 $\begin{pmatrix} 0 \\ 1 \end{pmatrix}$。
2. 计算张量积:
   • psi = zero.tensor(one): 这行代码是核心操作。
   • 它调用了我们刚刚创建的 zero 对象（代表 $\vert 0 \rangle$）的 tensor 方法。
   • 并将 one 对象（代表 $\vert 1 \rangle$）作为参数传入。
   • 这执行了张量积运算 $\vert 0 \rangle \otimes \vert 1 \rangle$。
   • 运算结果是一个新的 Statevector 对象，它代表了双量子比特系统的状态 $\vert 01 \rangle$，这个新对象被赋值给了变量 psi。
   • 在数学上，psi 内部存储的向量是 $\begin{pmatrix} 0 \\ 1 \\ 0 \\ 0 \end{pmatrix}$。
3. 显示结果:
   • display(psi.draw("latex")): 这行代码用于将结果以美观的数学形式展示出来。
   • psi.draw("latex"): psi 对象有一个 draw 方法，可以将其表示的量子态以不同的格式绘制出来。参数 "latex" 表示我们希望生成一个使用 LaTeX 格式化的字符串。对于状态 $\vert 01 \rangle$，这个方法会生成字符串 '$|01\\rangle$'。
   • display(...): 这是一个在 Jupyter Notebook 或类似交互式环境中常用的函数，它可以识别并正确渲染多种类型的对象，包括 LaTeX 字符串。当它接收到 LaTeX 格式的字符串时，会将其渲染成漂亮的数学公式。
   • $$ |01\rangle $$
     : 这是 display 函数渲染后的最终输出，直观地告诉我们 psi 变量所代表的量子态是 $\vert 01 \rangle$。

这段文字和公式扩展了 from_label 方法的功能，介绍了更多可以使用的预定义标签，并给出了两个新标签 "r" 和 "l" 的数学定义。

1. 扩展 from_label 的功能:
   • 前面我们已经看到了 "0" 和 "1" 这两个最基本的标签。这里告诉我们，from_label 方法还支持其他常用的单量子比特态的标签。
   • "+" 和 "-": 这两个标签分别对应量子态 $\vert + \rangle$ 和 $\vert - \rangle$。
   • $\vert + \rangle = \frac{1}{\sqrt{2}}(\vert 0 \rangle + \vert 1 \rangle)$，在布洛赫球面上指向 X 轴正方向。
   • $\vert - \rangle = \frac{1}{\sqrt{2}}(\vert 0 \rangle - \vert 1 \rangle)$，在布洛赫球面上指向 X 轴负方向。
   • "r" 和 "l": 这两个是新引入的标签。
   • 它们是 "right" 和 "left" 的缩写，这里的“左右”是指在布洛-赫球面的赤道上，沿着 Y 轴的方向。
   • "r" 对应 $\vert {+i} \rangle$，也常被写作 $\vert R \rangle$，指向 Y 轴正方向。
   • "l" 对应 $\vert {-i} \rangle$，也常被写作 $\vert L \rangle$，指向 Y 轴负方向。
2. 公式定义:
   • 公式明确给出了 $\vert {+i} \rangle$ 和 $\vert {-i} \rangle$ 的数学表达式。这两个状态是 $\vert 0 \rangle$ 和 $\vert 1 \rangle$ 的复数叠加。它们和 $\vert + \rangle, \vert - \rangle$ 一样，都是等权重的叠加态（概率幅的模都是 $\frac{1}{\sqrt{2}}$），测量时得到 0 或 1 的概率都是 50%。它们的区别在于相对相位 (relative phase)。
3. 引出示例:
   • 这是一个 ... 张量积示例: 这句话设置了悬念，预告了接下来的代码块将会演示如何用这些新标签创建量子态，并计算它们的张量积，具体是 $\vert + \rangle \otimes \vert {-i} \rangle$。

这个代码块和输出结果是前面理论的直接应用，演示了如何创建两个复杂的叠加态并计算它们的张量积。

1. 创建叠加态:
   • plus = Statevector.from_label("+"): 使用标签 "+" 创建一个 Statevector 对象，代表量子态 $\vert + \rangle = \frac{1}{\sqrt{2}}(\vert 0 \rangle + \vert 1 \rangle)$。变量 plus 现在持有了这个状态。其向量表示为 $\frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ 1 \end{pmatrix}$。
   • minus_i = Statevector.from_label("l"): 使用标签 "l" 创建一个 Statevector 对象，代表量子态 $\vert {-i} \rangle = \frac{1}{\sqrt{2}}(\vert 0 \rangle - i\vert 1 \rangle)$。变量 minus_i 现在持有了这个状态。其向量表示为 $\frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ -i \end{pmatrix}$。
2. 计算张量积:
   • phi = plus.tensor(minus_i): 这行代码计算了这两个态矢量的张量积，即 $\vert \phi \rangle = \vert + \rangle \otimes \vert {-i} \rangle$。
   • 运算的结果是一个代表双量子比特系统的新 Statevector 对象，被赋值给变量 phi。
3. 显示结果:
   • display(phi.draw("latex")): 和之前一样，这行代码将 phi 所代表的复杂量子态以 LaTeX 格式的数学公式清晰地展示出来。

这段内容介绍了 Qiskit 中执行张量积运算的另一种更简洁的语法——使用 ^ (caret) 运算符。

1. 语法糖 (Syntactic Sugar):
   • 另一种方法是使用 ^ 运算...: 这句话指出，除了调用 .tensor() 方法外，还有一个等效的快捷方式。
   • 在编程中，这种为了让代码更简洁、更易读而设计的、不增加新功能但提供替代写法的语法，被称为“语法糖”。
   • Qiskit 的设计者重载（overloaded）了 ^ 运算符，使其对于 Statevector 和 Operator 对象来说，执行的是张量积运算，而不是它在 Python 中通常表示的“按位异或”(bitwise XOR) 运算。
2. 代码示例:
   • plus ^ minus_i: 这里的 plus 和 minus_i 是之前创建的 Statevector 对象。
   • ^ 运算符在这里被 Qiskit 解释为“计算 plus 和 minus_i 的张量积”。
   • 这行代码 (plus ^ minus_i) 的效果与 plus.tensor(minus_i) 完全相同。
   • .draw("latex") 和 display(...) 的作用也和之前一样，用于将结果格式化并显示出来。
3. 结果验证:
   • 输出的 LaTeX 公式与前一个代码块的输出完全一样，这证明了 ^ 运算符确实是 .tensor() 方法的等价写法。

这段内容将张量积的概念从态矢量 (Statevector) 扩展到了算符 (Operator)。它表明，描述组合系统的操作也是通过张量积来构建的。

1. 理论扩展:
   • Operator 类也有一个 tensor 方法...`: 这句话是关键。正如组合系统的状态空间是子系统空间张量积一样，作用于组合系统上的算符也是由作用于子系统上的算符张量积而成的。
   • 如果算符 $A$ 作用于系统1，算符 $B$ 作用于系统2，那么作用于组合系统上的、表示“在系统1上做A操作，同时在系统2上做B操作”的联合算符就是 $A \otimes B$。
   • ...（以及一个 from_label 方法）: 这提示我们，Operator 类同样提供了便捷的标签来创建标准量子门，就像 Statevector 创建标准量子态一样。
2. 代码实现:
   • H = Operator.from_label("H"): 使用标签 "H" 创建一个 Operator 对象，代表哈达玛门 (Hadamard gate)。
   • Id = Operator.from_label("I"): 使用标签 "I" 创建一个代表单位门 (Identity gate) 的 Operator。单位门表示“什么都不做”。
   • X = Operator.from_label("X"): 使用标签 "X" 创建一个代表泡利-X门 (Pauli-X gate) 或比特翻转门的 Operator。
   • display(H.tensor(Id).draw("latex")): 这行计算了 $H \otimes I$ 的张量积。这是一个作用于双量子比特系统上的算符，其物理意义是“对第一个量子比特施加哈达玛门，同时对第二个量子比特施加单位门（即保持不变）”。结果是一个 4x4 的矩阵，代码将其以 LaTeX 格式显示。
   • display(H.tensor(Id).tensor(X).draw("latex")): 这行通过链式调用 tensor 方法，计算了 $H \otimes I \otimes X$ 的张量积。这是一个作用于三量子比特系统上的算符，表示“对第一个量子比特用H门，第二个不变，第三个用X门”。结果是一个 8x8 的矩阵。

这一部分再次强调了 ^ 运算符作为张量积快捷方式的通用性，并展示了它同样适用于 Operator 对象。

1. 重申等效性:
   • 同样，就像在矢量情况下一样，^ 运算是等效的。: 这句话明确指出，之前为 Statevector 介绍的 ^ 语法糖，对 Operator 类也同样有效。
2. 代码示例:
   • H ^ Id ^ X: 这里 H, Id, X 都是 Operator 对象。
   • ^ 运算符被依次用于计算张量积。这个表达式等价于 (H.tensor(Id)).tensor(X)。
   • 这种链式写法 A ^ B ^ C 非常直观地对应了数学上的 $A \otimes B \otimes C$。
   • 代码计算了 $H \otimes I \otimes X$ 这个三量子比特算符的矩阵表示。
3. 结果验证:
   • 输出的 8x8 矩阵与前一个代码块中使用 .tensor() 方法链式调用得到的结果完全相同。这再次证明了 A ^ B 是 A.tensor(B) 的完全等价物，无论 A 和 B 是 Statevector 还是 Operator。

这一部分将前面介绍的复合量子态和复合算符结合起来，演示了如何模拟一个多量子比特系统的量子演化。

1. 核心思想:
   • 复合量子态可以使用复合操作进行演化...: 这句话点明了本节的核心：量子演化的规则对于多量子比特系统是普适的。
   • 在单量子比特系统中，如果状态是 $\vert \psi \rangle$，施加操作 $U$ 后，新状态是 $U \vert \psi \rangle$。
   • 在多量子比特系统中，规则完全一样：如果复合状态是 $\vert \Psi \rangle$（一个张量积态或纠缠态），施加复合操作 $\mathbf{U}$ (一个张量积算符)后，新状态是 $\mathbf{U} \vert \Psi \rangle$。
   • 这里的运算就是标准的矩阵乘以向量。
2. 代码解释:
   • phi: 这是我们之前创建的 Statevector 对象，代表状态 $\vert\phi\rangle = \vert + \rangle \otimes \vert {-i}\rangle$。
   • H ^ Id: 这是我们之前创建的 Operator 对象，代表复合算符 $H \otimes I$。它表示对第一个量子比特施加 H 门，第二个量子比特不变。
   • phi.evolve(H ^ Id): 这是关键的演化步骤。
   • .evolve() 是 Statevector 对象的一个方法，它的作用就是将一个算符作用于该态矢量上。
   • 它接收一个 Operator 对象作为参数。
   • 这行代码计算了 $(H \otimes I) \vert \phi \rangle$。
   • evolve 方法会返回一个新的 Statevector 对象，代表演化后的新状态。
   • display(... .draw("latex")): 将演化后的新状态以 LaTeX 格式显示出来。

这段内容通过一个非常重要的例子——生成贝尔态——来演示一个不可分离（纠缠）操作的应用。

1. 定义 CNOT 门:
   • CX = Operator([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]): 这行代码直接通过提供一个 4x4 矩阵来创建一个 Operator 对象。
   • 这个矩阵是控制非门 (Controlled-NOT, CNOT, CX) 的标准矩阵表示。
   • CNOT 门的工作方式: 它是一个双量子比特门。它有一个控制量子比特和一个目标量子比特。
   • 如果控制量子比特是 $\vert 0 \rangle$，它对目标量子比特什么都不做（施加 I 门）。
   • 如果控制量子比特是 $\vert 1 \rangle$，它对目标量子比特进行翻转（施加 X 门）。
   • 矩阵解释: 该 4x4 矩阵作用在基矢 $\vert 00 \rangle, \vert 01 \rangle, \vert 10 \rangle, \vert 11 \rangle$ 上。
   • 第一列 [1,0,0,0] 表示 $CX\vert 00 \rangle = \vert 00 \rangle$ (控制位是0，目标位0不变)。
   • 第二列 [0,1,0,0] 表示 $CX\vert 01 \rangle = \vert 01 \rangle$ (控制位是0，目标位1不变)。
   • 第三列 [0,0,0,1] 表示 $CX\vert 10 \rangle = \vert 11 \rangle$ (控制位是1，目标位0翻转成1)。
   • 第四列 [0,0,1,0] 表示 $CX\vert 11 \rangle = \vert 10 \rangle$ (控制位是1，目标位1翻转成0)。
   • 左侧量子比特是控制位，右侧量子比特是目标位: 这句话明确了量子比特的角色。在 Qiskit 的 $\vert q_1 q_0 \rangle$ 约定中，$q_1$（左侧）是控制位，$q_0$（右侧）是目标位。
2. 准备初始态:
   • psi = plus.tensor(zero): 创建初始量子态 $\vert \psi \rangle = \vert + \rangle \otimes \vert 0 \rangle$。
   • plus 是 $\vert + \rangle = \frac{1}{\sqrt{2}}(\vert 0 \rangle + \vert 1 \rangle)$。
   • zero 是 $\vert 0 \rangle$。
   • 所以 $\vert \psi \rangle = \frac{1}{\sqrt{2}}(\vert 0 \rangle + \vert 1 \rangle) \otimes \vert 0 \rangle = \frac{1}{\sqrt{2}}(\vert 00 \rangle + \vert 10 \rangle)$。这是一个可分离态。
3. 执行演化:
   • display(psi.evolve(CX).draw("latex")): 计算 $CX \vert \psi \rangle$ 并显示结果。
   • 这一步是量子纠缠产生的关键。
4. 结果:
   • 结果是贝尔态 $\vert\phi^{+}\rangle$: 文字点明了输出结果是一个著名的纠缠态——贝尔态 Bell state $\vert\phi^{+}\rangle$。
   • 输出的 LaTeX 公式就是 $\vert\phi^{+}\rangle$ 的数学表达式。

这段话是对 measure 方法功能的复习和概括，为接下来引入“部分测量”的新功能做铺垫。

1. 回顾 measure 方法:
   • 在上一课中，我们使用了 measure 方法...: 提醒读者这个方法不是全新的，之前在单量子比特的上下文中已经接触过。
   • measure 是 Statevector 对象的一个核心方法，它模拟了量子力学中的测量过程。
2. measure 方法的输出:
   • 该方法返回两个项目: 明确指出调用 measure() 会得到一个包含两个元素的元组 (tuple)。
   • 第一个项目：测量结果
   • 这是一个字符串，表示测量坍缩到了哪个计算基矢。例如，对于单量子比特态，结果可能是 "0" 或 "1"。对于双量子比特态，可能是 "00", "01", "10", "11" 中的一个。
   • 这个结果是概率性的。根据波恩规则 (Born rule)，测量得到某个基矢的概率等于其对应概率幅的模平方。每次调用 measure，它都会根据这些概率随机返回一个结果。
   • 第二个项目：测量后的新状态
   • 测量过程会不可逆地改变量子态，使其“坍缩”到测量结果所对应的那个基矢上。
   • measure 方法返回的第二个项目就是一个新的 Statevector 对象，它代表了这个坍缩后的状态。例如，如果一个叠加态 $\alpha \vert 0 \rangle + \beta \vert 1 \rangle$ 被测量得到了结果 "0"，那么返回的新 Statevector 就将是纯态 $\vert 0 \rangle$。

这段文字引入了本节的一个核心新知识点：部分测量，并解释了如何在 measure 方法中实现它。

1. measure 方法的两种模式:
   • 默认模式（完全测量）: 默认情况下， measure 会测量态矢量中的所有量子比特。当你调用 sv.measure() 不带任何参数时，它会对系统中的每一个量子比特都进行测量。对于 N-量子比特系统，结果将是一个长度为 N 的字符串。
   • 部分测量模式: 或者，我们可以提供一个整数列表作为参数...。这是新功能。通过向 measure 方法传递一个列表，例如 sv.measure([0]) 或 sv.measure([1, 2])，你可以精确地指定只测量列表中的那些量子比特，而保持其他量子比特的状态不变（或者说，让它们根据测量结果进行相应的坍缩）。
2. Qiskit 的比特编号约定:
   • (Qiskit 从 0 开始为量子比特编号，从右到左。...): 这是一个极其重要的约定说明！
   • 从 0 开始: 量子比特的索引是从 0 开始的，这符合计算机科学中数组索引的惯例。
   • 从右到左: 这是最容易混淆的地方。在狄拉克符号 $\vert q_{N-1}...q_1q_0 \rangle$ 中，最右边的量子比特 $q_0$ 是 0 号量子比特， $q_1$ 是 1 号，以此类推。
   • 所以，当我们说 measure([0]) 时，我们指的是测量最右边的那个量子比特。
3. 示例的设置:
   • 为了演示部分测量，作者设计了一个特殊的状态 $\vert w \rangle$。
   • 这个状态是一个三量子比特的叠加态，由 $\vert 001 \rangle$, $\vert 010 \rangle$, 和 $\vert 100 \rangle$ 这三个基矢等权重叠加而成。（注意这里的权重是概率幅，所以系数是 $1/\sqrt{3}$）。
   • 这个状态被称为 W 态，是一种与贝尔态不同类型的纠缠态。
   • 选择这个状态是因为它的特性非常适合用来展示部分测量的效果。例如，如果我们测量0号量子比特（最右边的），它可能是0或1。
   • 如果测得 1，系统会坍缩到 $\vert 001 \rangle$。
   • 如果测得 0，系统会坍缩到 $\vert 010 \rangle$ 和 $\vert 100 \rangle$ 的叠加态上。
   • 并测量 0 号量子比特，即最右边的量子比特: 这句话明确了接下来代码将要执行的操作，为读者提供了清晰的预期。

这段代码和输出是本课程的核心演示，通过在 W 态上进行两次连续的部分测量，完整展示了部分测量的机制和效果。

1. 创建 W 态:
   • w = Statevector([0, 1, 1, 0, 1, 0, 0, 0] / sqrt(3)): 这行代码直接通过一个向量列表来创建量子态。
   • 这是一个三量子比特系统，所以向量有 $2^3 = 8$ 个分量。
   • 这些分量按顺序对应基矢 $\vert 000 \rangle, \vert 001 \rangle, \vert 010 \rangle, \vert 011 \rangle, \vert 100 \rangle, \vert 101 \rangle, \vert 110 \rangle, \vert 111 \rangle$。
   • 列表 [0, 1, 1, 0, 1, 0, 0, 0] 表示在 $\vert 001 \rangle$ (第1个索引)、$\vert 010 \rangle$ (第2个索引)、$\vert 100 \rangle$ (第4个索引) 的位置有非零的概率幅。
   • / sqrt(3) 是进行归一化，使得每个非零幅值都是 $1/\sqrt{3}$。
   • display(w.draw("latex")): 将创建的 W 态以 LaTeX 格式显示，输出结果与我们期望的 $\frac{1}{\sqrt{3}}(\vert 001\rangle + \vert 010\rangle + \vert 100\rangle)$ 相符（其中 $\frac{1}{\sqrt{3}}$ 写成了 $\frac{\sqrt{3}}{3}$）。
2. 第一次部分测量:
   • result, state = w.measure([0]): 对 W 态 w 测量 0 号量子比特（最右边的那个）。
   • print(f"Measured: {result}\nState after measurement:"): 打印测量结果和提示信息。
   • 输出分析:
   • Measured: 0: 在这次随机运行中，测量 0 号量子比特的结果是 "0"。根据我们之前的理论推导，这件事发生的概率是 2/3。
   • State after measurement:: 提示下面显示的是坍缩后的状态。
   • LaTeX 输出
     $$ \frac{\sqrt{2}}{2} |010\rangle+\frac{\sqrt{2}}{2} |100\rangle $$
     : 这正是我们理论推导出的、当测得 q0=0 时的坍缩后状态！它是一个归一化后的、由 $\vert 010 \rangle$ 和 $\vert 100 \rangle$ 构成的叠加态。
3. 第二次部分测量:
   • result, state = w.measure([0, 1]): 注意！ 这里的 w.measure(...) 是对原始的 W 态 w 进行的又一次独立的测量，而不是对第一次测量后的 state 进行的。这次测量的是 0 号和 1 号量子比特（最右边的两个）。
   • print(...): 同样打印结果。
   • 输出分析:
   • Measured: 00: 在这次随机运行中，测量 q1 和 q0 的结果是 "00"。
   • LaTeX 输出
     $$ |100\rangle $$
     : 这是坍缩后的状态。我们来验证一下：
   • 理论推导: 原始 W 态是 $\frac{1}{\sqrt{3}}(\vert 001\rangle + \vert 010\rangle + \vert 100\rangle)$。
   • 我们要找 q1=0 且 q0=0 的部分。只有 $\vert 100 \rangle$ 这一项符合。
   • 概率: 测得 "00" 的概率是 $|1/\sqrt{3}|^2 = 1/3$。
   • 坍缩: 因为只有 $\vert 100 \rangle$ 这一项的 q1q0 是 "00"，所以当测得 "00" 时，系统会确定性地坍缩到 $\vert 100 \rangle$ 态。
   • 代码的输出与理论完全吻合。

这是一个版权声明。

• ©: 这是版权符号 (Copyright symbol)。
• IBM Corp.: 指的是国际商业机器公司 (International Business Machines Corporation)，Qiskit 项目的发起者和主要维护者。
• 2017-2025: 这表示该材料的版权从 2017 年开始，并持续有效至 2025 年。这个时间范围表明，这份教程内容最早创作于 2017 年，并且在之后有持续的更新。