本章涵盖了以下内容：

1. 抛硬币和获取随机数之间的类比
2. 关联抛硬币和概率向量
3. 量子纠缠的物理概念
4. 利用量子纠缠创建连接的随机数
5. 理解如何在Java应用程序中使用叠加态和纠缠

在前一章中，我们介绍并解释了叠加态的概念。这个概念在经典计算中是不存在的，它是量子计算与经典计算根本不同的原因之一。尽管如此，我们设法以一种Java程序员可以在代码中使用的方式描述叠加态。在本章中，我们将介绍量子纠缠，这是经典计算中也没有遇到的一个概念，使得量子计算具有强大的能力。同样，我们将展示如何通过使用Java代码模拟和处理量子纠缠。

预测正面或反面

在魔术表演中，你是否曾经看过魔术师能够预测看似随机的事物？比如，一位观众从一副扑克牌中选一张牌，魔术师没有看到牌面却能准确说出选中的是哪张牌。或者，观众掷掷硬币并隐藏结果，而魔术师却能知道硬币是正面朝上还是反面朝上。

在本章中，您将学习编写类似的代码，但这里没有任何魔法。您只会使用量子物理的编程影响。

在整个本章中，我们使用旋转硬币的类比，硬币可能会落在正面或反面。首先，您将编写经典代码来模拟两个旋转的硬币并测量结果。接下来，您将编写一个量子算法，利用前一章中解释的叠加原理来实现相同的效果。最后，您将使用一种新的门，使这两个硬币纠缠在一起。尽管测量的结果仍然是随机的，但测量其中一个硬币的结果将告诉您另一个硬币的值。如图5.1所示。

独立概率：经典方法

假设你有两枚硬币，硬币A和硬币B。每枚硬币可以是正面或反面。你将这两枚硬币同时抛掷，并在它们旋转时将它们移到不同的房间。然后等待硬币停止旋转，观察它们是正面还是反面。我们无法确定结果是什么，但我们可以对概率做出一些说明。硬币A是正面的概率为50%，硬币A是反面的概率也为50%。同样地，硬币B是正面的概率为50%，硬币B是反面的概率也为50%。如果我们将正面结果与数值0关联，将反面结果与数值1关联，那么硬币被测量为0的概率是50%，硬币被测量为1的概率也是50%，如图5.2所示。

总体上，我们可以测量到四种可能的组合：

• 硬币A是正面（0），硬币B也是正面（0）。我们用二进制表示为00，对应十进制表示为0。
• 硬币A是正面（0），硬币B是反面（1）。我们用二进制表示为01，对应十进制表示为1。
• 硬币A是反面（1），硬币B是正面（0）。我们用二进制表示为10，对应十进制表示为2。
• 硬币A是反面（1），硬币B是反面（1）。我们用二进制表示为11，对应十进制表示为3。

正如我们之前所述，处理量子计算时我们经常谈论概率。在这种情况下，我们有四种可能的结果，每个结果都有特定的概率。因此，这些概率可以存储在一个数组中，其中十进制表示是该数组中的索引。该数组也被称为概率向量。图5.3展示了正面/反面、二进制位和十进制数之间的转换。

如果硬币是完全公平的，每种组合发生的概率是相等的。因此，由于总概率必须为100%，每种组合的测量概率都是25%。在这种情况下，概率向量可以表示如下：

因此，如果我们进行1,000次不同的独立测量，我们预计每种组合会被测量大约250次左右。我们不需要量子计算机来测试这一点；我们可以使用经典软件。classiccoin示例包含一个名为TwoCoins的类，该类执行大部分计算工作。

private static final int count = 1000;               ❶
private static final Random random = new Random();   ❷
 
private static boolean randomBit() {                 ❸
    boolean answer = random.nextBoolean();
    return answer;
}
 
public static int[] calculate(int count) {           ❹
    int results[] = new int[4];
    for (int i = 0; i < count; i++) {
        boolean coinA = randomBit();                 ❺
        boolean coinB = randomBit();
        if (!coinA && !coinB) results[0]++;          ❻
        if (!coinA && coinB) results[1]++;
        if (coinA && !coinB) results[2]++;
        if (coinA && coinB) results[3]++;
    }
    return results;                                  ❼
}

❶ 进行1,000次实验

❷ 使用Random生成随机值

❸ 创建并返回一个随机的布尔值

❹ 计算可以为头或为尾的两个硬币的概率向量

❺ 创建两个随机位，可以是true或false，并且彼此之间是独立的

❻ 根据两个位的值，在概率向量中递增一个元素

❼ 将概率向量返回给函数的调用者

randomBit() 函数返回一个随机的布尔值。Java 中使用 Math.random() 函数来生成一个在 0 到 1 之间的随机数。这个随机数有50%的概率小于0.5，这种情况下随机布尔值返回 0；还有50%的概率大于0.5，这种情况下随机布尔值返回 1。

calculate(int count) 函数接受一个整数作为输入，用于定义需要进行实验的次数。它返回一个包含四个整数的数组，每个整数表示实验导致特定结果的次数。在每次实验中，使用 randomBit() 函数获得两个随机的布尔值（coinA 和 coinB）。根据图 5.3 中所示的转换规则，递增其中一个计数器。如果 coinA 为 true 并且 coinB 为 false，则得到一个尾部-头部的结果，等同于 10 的结果，并且索引为 2 的计数器将被递增。该应用程序的主要方法如下：

public static void main(String[] args) {
    int results[] = TwoCoins.calculate(count);                ❶
    System.out.println("We did "+count+" experiments.");      ❷
    System.out.println("0 0 occurred "+results[0]+" times.");
    System.out.println("0 1 occurred "+results[1]+" times.");
    System.out.println("1 0 occurred "+results[2]+" times.");
    System.out.println("1 1 occurred "+results[3]+" times.");
    Platform.startup(() -> showResults(results));             ❸
}

❶ 调用 calculate 函数，返回包含不同可能结果出现次数的数组。

❷ 打印不同的结果。

❸ 在图表中显示结果。

注意：用于在图表中显示结果的代码使用了 JavaFX，但这些细节超出了本书的范围。

如果你运行这个应用程序，你会看到一个分布大致均匀的结果：

We did 1000 experiments.
0 0 occurred 272 times.
0 1 occurred 239 times.
1 0 occurred 243 times.
1 1 occurred 246 times.

该应用程序还显示了此分布的图表，参见图5.4。如果您多次运行此应用程序，各个概率值将会不同。但总体上，所有概率值都是等可能的；因此，这些数字都在相同的范围内。

独立概率：量子方式

到目前为止，我们的实验还没有什么令人激动的地方。我们展示了如何使用经典算法在经典计算机上模拟硬币的随机值。现在我们转向量子计算机并做类似的事情。在前一章中，我们使用量子门创建了一个随机数生成器。具体来说，我们学习了Hadamard门如何将一个量子比特带入叠加态。当进行测量时，量子比特会坍缩到其中一个基态，并且我们会测量到0或1的值。

如果我们在前一章的系统中添加另一个量子比特，并对该量子比特也应用Hadamard门，我们可以使用量子比特来模拟前面（经典）示例中的两个硬币。电路如图5.5所示。

现在让我们编写生成这个电路并测量结果的代码。这个示例的代码位于示例存储库的ch05/quantumcoin目录中，下面是代码示例：

private static final int COUNT = 1000;                      ❶
 
public static void main(String[] args) {
    int results[] = new int[4];                             ❷
    QuantumExecutionEnvironment simulator = new
            SimpleQuantumExecutionEnvironment();            ❸
    Program program = new Program(2);
    Step step1 = new Step();
    step1.addGate(new Hadamard(0));
    step1.addGate(new Hadamard(1));
    program.addStep(step1);
    for (int i = 0; i < COUNT; i++) {                       ❹
        Result result = simulator.runProgram(program);
        Qubit[] qubits = result.getQubits();
        Qubit zero = qubits[0];
        Qubit one = qubits[1];
        boolean coinA = zero.measure() == 1;
        boolean coinB = one.measure() == 1;
        if (!coinA && !coinB) results[0]++;                 ❺
        if (!coinA && coinB) results[1]++;
        if (coinA && !coinB) results[2]++;
        if (coinA && coinB) results[3]++;
    }
    System.out.println("We did "+COUNT+" experiments.");
    System.out.println("[AB]: 0 0 occurred "+results[0]+" times.");
    System.out.println("[AB]: 0 1 occurred "+results[1]+" times.");
    System.out.println("[AB]: 1 0 occurred "+results[2]+" times.");
    System.out.println("[AB]: 1 1 occurred "+results[3]+" times.");
 
    Renderer.renderProgram(program);                        ❻
    Renderer.showProbabilities(program, 1000);              ❼
 
}

❶ 进行了 1,000 次实验

❷ 结果数组包含了不同可能结果的出现次数

❸ 创建了 quantumExecutionEnvironment，并构建了程序

❹ 执行了 1,000 次程序，并测量了结果

❺ 根据结果，增加其中一个计数器的值

❻ 显示了该程序的电路

❼ 在用户界面中显示了不同可能结果的概率

如果您运行这段代码，您会看到一个类似于经典情况的分布。程序会打印以下输出：

We did 1000 experiments.
[AB]: 0 0 occurred 246 times.
[AB]: 0 1 occurred 248 times.
[AB]: 1 0 occurred 244 times.
[AB]: 1 1 occurred 262 times.

该程序还可视化输出结果。图5.6显示了电路和分布情况。

所有结果的概率都为25%。例如，一个实验有25%的机会得到概率指数0，即对应于测量结果00。其他所有结果也有25%的机会。

如果分析代码或查看图5.5中的电路，就可以预期这种结果。在代码中，通过使用合适的构造函数创建了一个涉及两个量子比特的量子程序：

Program program = new Program(2);

这个程序包含一个步骤。在这个步骤中，你为每个单独的量子比特分配了一个Hadamard门：

Step step1 = new Step();
step1.addGate(new Hadamard(0));
step1.addGate(new Hadamard(1));

通过以下代码将该步骤添加到程序中：

program.addStep(step1);

因此，你创建的程序包含一个包含在每个单独量子比特上的Hadamard门的步骤。直观上来说，很明显这两个量子比特之间没有联系，且当测量时，它们都会随机地显示0或1，彼此之间是独立的。这与我们在上一节中展示的经典位类似。

量子纠缠的物理学概念

在前一节中的算法中，我们展示了如何使用量子算法实现与经典算法相同的结果。但我们承诺会超越经典的能力。

在本节中，我们将暂时回到物理世界，解释量子纠缠的物理概念。之后，我们将回到软件世界，并展示如何表示这一现象。

利用物理表示的量子比特，我们可以实现经典位的物理表示无法实现的事情，并且我们可以在软件表示中使用这一特性。在经典软件中，两个不同的位不会相互影响。当然，我们可以将一个位的值复制到另一个位，但这样做是显式地为第二个位赋值。

现在我们要使用的量子现象称为量子纠缠。这是一种最奇怪的物理现象之一，一些历史上最杰出的物理学家对此进行了激烈的讨论。关于量子纠缠是什么以及它如何与其他物理概念相符，仍然存在着持续的争论。

我们之前说过，量子比特的物理表示具有一个特性（我们称之为自旋），可以处于两种状态之一，也可以处于这两种状态的叠加状态。我们可以创建许多量子比特，并将它们置于叠加态。这是前一节中的基本物理方法。如果我们将我们的应用程序发送到真正的量子计算机，相应的物理流程将是两个量子比特都被置于叠加态，然后进行测量。图5.7展示了这种分布。

如果对其中一个粒子进行测量，我们有50%的机会测量到自旋向上，另外50%的机会测量到自旋向下。如果我们测量另一个粒子，同样有50%的机会它处于自旋向上状态，另外50%的机会它处于自旋向下状态。第二次测量的结果与第一次测量的结果是独立的。这在图5.8中展示了出来。

正如您所看到的，测量会产生四种可能的结果。这对应于我们在前一节中所展示的情况：当测量两个相互独立的处于叠加态的量子比特时，会有四种可能的结果，每种结果的概率为25%。

令人惊奇的是，这种叠加态已经可以实现，而纠缠则更进一步。纠缠的粒子或量子比特共享它们的状态。它们可能看起来是独立的叠加粒子，但是一旦其中一个被测量，另一个的测量结果也随之确定。有多种方法可以创建两个纠缠的粒子，我们将避免讨论这个创建过程。但在示意图5.9中，可以用图示方式表示这个过程。

在这个方案中，在物理纠缠操作后，两个粒子都处于叠加态，所以目前看起来与之前的情况完全相同。然而，事实证明，当观察到纠缠对中的一个粒子并测量其状态时，另一个粒子的状态也会被确定。根据使用的纠缠技术，第二个粒子的状态将与第一个粒子的状态相同或相反。为简单起见，我们假设所使用的纠缠技术生成的两个粒子在测量时具有相同的状态。

当测量第一个粒子时，有50%的几率测量得到自旋向上，有50%的几率测量得到自旋向下。到目前为止，这与之前的情况完全相同（两个粒子处于叠加态）。当测量第二个粒子时，同样有50%的几率测量得到自旋向上，有50%的几率测量得到自旋向下。然而，这与之前的情况有着关键的不同之处：测量结果不再是相互独立的。当第一个粒子的测量结果为自旋向上时，第二个粒子也有100%的几率测量结果为自旋向上。而当第一个粒子的测量结果为自旋向下时，第二个粒子也有100%的几率测量结果为自旋向下。这在图5.10中有所展示。

在这种情况下，只有两种可能的结果，而不是之前的四种：{向上，向上} 或 {向下，向下}。每种结果的概率都是50%。不可能出现 {向上，向下} 或 {向下，向上} 这样的结果。因此，当我们测量单个粒子时，它们似乎会产生随机值。虽然这是正确的，但这些测量结果是100%相互依赖的。

注意：当两个粒子被纠缠在一起时，并不意味着它们都处于向上或向下状态，只是我们不知道它们是哪个状态。它们可以处于叠加态，直到其中一个被测量。这有重要的后果，正如我们在接下来的章节中所看到的。

在这次对物理世界的探讨之后，我们现在回到软件领域。我们需要找到一种方法，通过使用门来表示量子纠缠，以便我们可以创建程序。

量子纠缠的门表示法

在前一章中，您学到了物理概念"叠加态"如何通过Hadamard门在量子计算中应用。在本节中，我们将看到如何通过使用两种门的组合来使用量子纠缠的概念在量子计算中进行应用。

转换为概率向量

两个量子比特的纠缠结果是，当测量时，这两个量子比特要么都处于自旋向上状态，要么都处于自旋向下状态。我们将使用概率向量来表示这些信息，就像之前一样。请记住，自旋向上的量子比特对应于值1，自旋向下的量子比特对应于值0。因此，唯一可能的组合是00（两个量子比特都处于自旋向下状态）或11（两个量子比特都处于自旋向上状态）。我们需要创建的概率向量包含以下内容：

• 00（索引0）- 有50%的机会两个量子比特都处于自旋向下状态
• 01（索引1）- 0%的机会一个量子比特处于自旋向下状态，另一个量子比特处于自旋向上状态
• 10（索引2）- 0%的机会一个量子比特处于自旋向上状态，另一个量子比特处于自旋向下状态
• 11（索引3）- 有50%的机会两个量子比特都处于自旋向上状态

这对应于以下矩阵：

这个方程中的根号2是因为概率对应于特定位置上的值的平方。实际上，测量00（索引0）的概率是索引0处值的平方，即：

对应于50％。类似地，测量11（索引3）的概率是索引3处值的平方，也得到了50％。

测量01（索引1）的概率是索引1处值的平方，因此为0％。同样，测量10（索引2）的概率也是索引2处值的平方，同样为0％，

这对应于0％。

CNot门

我们现在需要找到一种门的组合，可以得到刚刚创建的概率向量。事实证明，这可以很容易地实现，但我们需要一个新的门：CNot门。CNot门作用于两个量子位，其符号表示如图5.11所示。

在CNot门中涉及的两个量子位通常称为控制量子位（顶部）和目标量子位（底部）。CNot门的行为如下：

• 如果控制量子位为|0〉，则什么都不会发生。CNot门之后的状态与CNot门之前的状态完全相同。
• 如果控制量子位为|1〉，则目标量子位会翻转：如果目标量子位为|0〉，则会翻转为|1〉；如果目标量子位为|1〉，则会翻转为|0〉。

我们可以通过一个简单的Strange应用程序来验证这一点。名为cnot的示例演示了四种不同情况下CNot门的工作方式。CNot门作用于两个量子位，我们检查了四种不同的边缘情况，其中量子位处于|0〉或|1〉状态。该示例的主要方法如下调用这四种情况：

public static void main(String[] args) {
    run00();
    run01();
    run10();
    run11();
}

run00()方法将CNot门应用于两个处于|0〉状态的量子位。run01()方法处理的是第一个量子位处于|0〉状态，第二个量子位处于|1〉状态的情况。类似地，run10()方法将CNot门应用于第一个量子位处于|1〉状态，第二个量子位处于|0〉状态的量子组。最后，run11()方法将CNot门应用于两个都处于|1〉状态的量子位。

在第一种情况下，我们使用run00()方法，即在应用CNot门之前，两个量子位都处于|0〉状态。因为控制量子位（第一个量子位）是|0〉，所以我们预计在结果中不会有任何变化。图5.12显示了视觉结果。如预期的那样，该电路的结果始终将量子位设为0，这意味着当我们测量时，我们总是测量到0。

让我们来看一下导致这个输出的代码。到目前为止，代码中的大多数语句应该看起来很熟悉：

QuantumExecutionEnvironment simulator =
        new SimpleQuantumExecutionEnvironment();    ❶
Program program = new Program(2);                   ❷
Step step1 = new Step();
step1.addGate(new Cnot(0,1));                       ❸
program.addStep(step1);
Result result = simulator.runProgram(program);
Qubit[] qubits = result.getQubits();                ❹
Qubit q0 = qubits[0];
Qubit q1 = qubits[1];
int v0 = q0.measure();
int v1 = q1.measure();
System.out.println("v0 = "+v0+" and v1 = "+v1);
Renderer.renderProgram(program);                    ❺

❶ 创建一个新的环境来运行我们的量子程序

❷ 创建一个在两个量子比特上运行的量子程序

❸ 向这个程序的第一个（也是唯一的）步骤添加了一个CNot门。因为CNot门作用在两个量子比特上，我们需要指定哪两个量子比特。因此，CNot的构造函数需要两个参数：控制量子比特（在本例中是第一个比特，索引为0）和目标量子比特（第二个比特，索引为1）。

❹ 执行程序，并测量结果

❺ 显示程序和测量结果

其他三种情况需要一个额外的步骤：在应用CNot门之前，至少需要将其中一个量子比特置于|1〉状态。正如您在第3章学到的那样，可以通过应用Pauli-X门来实现这一点。以下代码片段显示了如何创建应用于控制量子比特为|0〉且目标量子比特最初为|1〉的情况的程序：

Program program = new Program(2);
Step step1 = new Step();             ❶
step1.addGate(new X(1));             ❷
program.addStep(step1);
Step step2 = new Step();
step2.addGate(new Cnot(0,1));        ❸
program.addStep(step2);

❶ 创建第一个步骤

❷ 对目标量子比特（索引为1）应用Pauli-X门，并将其添加到此步骤中

❸ 创建第二个步骤，这次使用CNot门，并将其添加到程序中

图5.13显示了这个电路的可视化输出。输入状态为|01>和|11>的代码类似，并且您可以在示例中找到它们。

如果您运行这个示例，您将会看到四个不同的可视化效果，展示了程序在四种不同的输入状态下的输出结果。图5.14和图5.15展示了您还没有看到的两个可视化效果。总结起来，我们可以创建表5.1，显示了CNot门如何改变（或保持）控制量子位和目标量子位的值。

q0(before)	q1(before)	q0(after)	q1(after)
0	0	0	0
0	1	0	1
1	0	1	1
1	1	1	0

创建贝尔态：相关概率

在前一节中的四个例子中，输入到 CNot 门的情况是特殊情况，其中控制量子位是 |0〉或 |1〉。但是当控制量子位处于叠加态时，我们应该期望什么结果，如图 5.16 所示？

从前一章中记得，你可以使用 Hadamard 门将量子位带入叠加态。创建此电路的代码可以在名为 "bellstate" 的示例中找到：

public static void main(String[] args) {
    QuantumExecutionEnvironment simulator = new SimpleQuantumExecutionEnvironment();
    Program program = new Program(2);
    Step step1 = new Step();
    step1.addGate(new Hadamard(0));
    program.addStep(step1);
    Step step2 = new Step();
    step2.addGate(new Cnot(0,1));
    program.addStep(step2);
    Result result = simulator.runProgram(program);
    Qubit[] qubits = result.getQubits();
    Qubit q0 = qubits[0];
    Qubit q1 = qubits[1];
    int v0 = q0.measure();
    int v1 = q1.measure();
 
    Renderer.renderProgram(program);
    Renderer.showProbabilities(program, 1000);
}

如果你运行这个应用程序，你会看到以下几行之一作为输出：

Result of H-CNot combination: q0 = 0, q1 = 0

或者

Result of H-CNot combination: q0 = 1, q1 = 1

无论你运行这个应用程序多少次，你会发现输出总是这两种结果之一。你永远不会看到

Result of H-CNot combination: q0 = 0, q1 = 1

或者

Result of H-CNot combination: q0 = 1, q1 = 0

当你运行应用程序时，除了文本输出外，你还会看到电路输出和概率分布。从电路输出（如图5.17所示）可以看出，qubit 0被测量为0的概率为50%，被测量为1的概率也是50%。同样，输出显示qubit 1被测量为0的概率为50%，被测量为1的概率也是50%。

这个结果与你多次运行示例时的观察结果相符，即第一个 qubit 和第二个 qubit 都可以被测量为 0 或 1。然而，这个输出并没有显示我们观察到的额外限制：这些组合是有限制的。从文本输出中的观察结果来看，如果第一个 qubit 被测量为 0，第二个 qubit 也会被测量为 0。当第一个 qubit 被测量为 1 时，第二个 qubit 也会被测量为 1。这在概率分布图中有显示，如图 5.18 所示。

这是一个有趣的结果。似乎在一个控制 qubit 处于叠加状态而目标 qubit 处于 |0〉状态的 qubit 对上应用 CNot 运算符总是导致一个纠缠态。我们在这里看到的结果恰好是我们之前描述的纠缠态。这个结果也被称为 Bell 态。

注意：当测量纠缠态的个别元素时，你所测量到的值似乎是完全随机的。尽管如此，纠缠态的比特元素之间有完全匹配的关系。

因此，通过使用 Hadamard gate 和 CNot gate 的组合，我们可以创建量子纠缠态。虽然“创建”这个词并不完全准确，因为我们并没有真正地创建纠缠态，但我们创建的电路产生了与两个纠缠态 qubit 状态相同的概率。这意味着我们找到了一种编程方式来表示量子纠缠行为。在接下来的章节中，我们会广泛地应用这种行为。

Mary有一个小的量子比特

现在您已经学习了量子计算的基本概念，可以开始在应用程序中使用它们。为了帮助您入门，我们创建了一个简单的游戏，基于Stephen Chin创建的Mary Had a Little Lambda应用程序，以演示在Java中使用流和Lambda的用法。（您可以在mng.bz/KoxP了解更多关于这个游戏的信息。）

我们修改了这个游戏，让Mary管理的是实际的量子比特。代码可以在代码库的ch05目录下找到，名称为maryqubit。您可以通过输入以下命令来启动它：

mvn clean javafx:run

执行上述命令后，会显示如图5.19所示的起始界面。

您会看到Mary在一个景观中，有几个元素。其中一些元素对应于量子门：当小羊访问处于活动状态的量子门时，该门将被应用到小羊的量子比特上。屏幕顶部显示了相应的电路。

在这个游戏中有很多东西可以发现，鼓励您浏览源代码。其中一个特别有趣的练习是：让Mary通过门，创建一个由三个量子比特组成的电路，显示Bell态和第三个量子比特上的Hadamard门。结果如图5.20所示。

如果您查看此游戏的代码，您将看到如何结合Strange模拟器、StrangeFX可视化和您自己的应用程序。StrangeBridge类是所有组件汇聚在一起的地方。

总结

• 量子纠缠是两个量子比特之间共享的状态，其中量子比特的性质不是独立的。
• 在量子计算中，我们可以利用量子纠缠和考虑纠缠的量子门。
• 使用Strange，您可以轻松创建两个纠缠的量子比特并测量它们的状态。