mindspore打卡之量子模拟器和线路

mindspore打卡之量子模拟器和线路

```python
import numpy as np                             # 导入numpy库并简写为np
from mindquantum.simulator import Simulator    # 从mindquantum.simulator中导入Simulator类
from mindquantum.core.gates import X, H, RY    # 导入量子门H, X, RY
```

    /home/ma-user/anaconda3/envs/Mindquantum-0.9.0/lib/python3.9/site-packages/mindquantum/simulator/__init__.py:17: UserWarning: Disable mqvector gpu backend due to: Malloc GPU memory failed: cudaErrorInsufficientDriver, CUDA driver version is insufficient for CUDA runtime version
      from .available_simulator import SUPPORTED_SIMULATOR

```python
sim = Simulator('mqvector', 2)   #声明一个两比特的mqvector模拟器
sim                              #展示模拟器状态
```

    mqvector simulator with 2 qubits (little endian), dtype: mindquantum.complex128.
    Current quantum state:
    1¦00〉

量子比特（qubit）的状态可以通过一个复数向量来表示，这个向量居住在一个二维复数向量空间，称为希尔伯特空间（Hilbert space）。具体来说，一个量子比特可以处于两个基本状态之一，通常标记为 |0〉 和 |1〉，这两个状态被称为计算基态。但在量子力学中，一个量子比特不仅可以处于这两个纯状态之一，还可以处于这两个状态的任意线性组合，这称为量子叠加态。

量子比特的叠加态可以用下面的公式表示：
\[
|\psi〉 = \alpha|0〉 + \beta|1〉
\]
其中，\(\alpha\) 和 \(\beta\) 是复数系数，满足 \(\left|\alpha\right|^2 + \left|\beta\right|^2 = 1\) 的条件，这是因为量子态必须归一化，确保概率总和为1。\(\left|\alpha\right|^2\) 和 \(\left|\beta\right|^2\) 分别代表量子比特处于状态 |0〉 和 |1〉 的概率幅的平方，也就是实际测量到该状态的概率。

除了用波函数（上述的线性组合）表示，量子比特的状态还可以通过密度矩阵的形式来表述，特别是在考虑量子系统的混合态或者对系统知识不完全确定的情况下。

在数学上，为了方便处理和可视化，经常使用向量表示法。对于单个量子比特，其状态可以简化表示为一个二维向量：
\[
|\psi〉 = \begin{bmatrix} \alpha \\ \beta \end{bmatrix}
\]
在多量子比特系统中，每个额外的量子比特会使得这个向量空间的维度翻倍，从而形成一个更大的向量或者张量积空间。例如，两个量子比特的系统会有一个四维的向量来表示其可能的状态，依此类推。这样的表示方法使得理解和操作多量子比特系统成为可能，也是构建量子算法和量子线路的基础。

量子态 |01〉 表示的是一个两量子比特系统中，第一个量子比特处于状态 |0〉，而第二个量子比特处于状态 |1〉。在量子计算中，两量子比特系统的状态通常使用计算基底的直积来表示。计算基底由四个状态组成：|00〉, |01〉, |10〉, 和 |11〉。

对于 |01〉 这个特定的态，其矩阵表示（或者说向量表示，因为在这种上下文中“矩阵”可能有点误导，实际上我们是在讨论一个列向量）是计算基底 |0〉 和 |1〉 的直积，但需要注意，由于采用了小端序（little endian），在表示两量子比特态时，第二个量子比特的状态放在前面，第一个量子比特的状态放在后面。

因此，|01〉 可以表示为：
\[
|01〉 = |0〉 \otimes |1〉 = \begin{bmatrix} 0 \\ 1 \end{bmatrix} \otimes \begin{bmatrix} 1 \\ 0 \end{bmatrix} = \begin{bmatrix} 0 \times \begin{bmatrix}1\\0\end{bmatrix} \\ 1 \times \begin{bmatrix}1\\0\end{bmatrix} \end{bmatrix} = \begin{bmatrix} 0 \\ 0 \\ 1 \\ 0 \end{bmatrix}
\]
这里，\(\otimes\) 表示直积运算。最终得到的四维向量就是 |01〉 在小端序下的标准列向量表示。

```python

```

根据提供的信息，“mqvector simulator with 2 qubits (little endian), dtype: mindquantum.complex128.” 描述的是使用了MindQuantum框架的一个模拟环境，它专门用于处理量子计算任务。这个模拟器处理的是2个量子比特的系统，并采用了小端序（little endian）的比特排列方式，意味着在表示量子态时，编号较小的比特位于描述态向量的右侧。此外，该模拟器使用`mindquantum.complex128`作为数据类型，表明它能够处理复数，并且每个复数由128位（即16字节）来存储，提供了高精度的复数运算能力，这对于模拟量子系统中的干涉和叠加现象至关重要。

当提到“Current quantum state: 1¦00〉”，这是在说当前的量子系统处于纯态 |\psi〉 = |00〉，即两个量子比特都处于基态 |0〉 上。在小端序表示中，尽管这个信息没有直接改变我们对 |00〉 的传统理解（因为无论是大端序还是小端序，|00〉 的表示都是相同的），但它确认了当前系统的具体状态。在这个状态下，量子态矢量可以表示为：
\[
|\psi〉 = |00〉 = \begin{bmatrix} 1 \\ 0 \\ 0 \\ 0 \end{bmatrix}
\]
这里，向量的右端（按小端序理解）对应于第一个（更低位）量子比特，而左端对应于第二个（更高位）量子比特，但由于两个比特均为0，所以向量的表示简单明了，且不受端序影响。

总结来说，这段描述指出了使用的模拟工具特性、量子比特数量、数据类型及当前系统的精确量子态。

态 |00〉 表示的是一个两量子比特系统中，两个量子比特都处于状态 |0〉。和之前一样，我们可以使用计算基底的直积来表示这个态。

对于 |00〉，它的矩阵表示（实际上是列向量表示）是两个 |0〉 状态的直积，即：

\[
|00〉 = |0〉 \otimes |0〉 = \begin{bmatrix} 1 \\ 0 \end{bmatrix} \otimes \begin{bmatrix} 1 \\ 0 \end{bmatrix} = \begin{bmatrix} 1 \times \begin{bmatrix}1\\0\end{bmatrix} \\ 0 \times \begin{bmatrix}1\\0\end{bmatrix} \end{bmatrix} = \begin{bmatrix} 1 \\ 0 \\ 0 \\ 0 \end{bmatrix}
\]

所以，|00〉 在小端序下表示为四维列向量 \([1, 0, 0, 0]\)，这表明系统处于第一个量子比特为0且第二个量子比特也为0的状态。

态 |0〉 的向量表示是由量子力学的基本假设和公设所规定的，特别是波函数的统计解释和希尔伯特空间的引入。具体来说：

1. **希尔伯特空间**: 在量子力学中，每一个量子系统都被指派一个希尔伯特空间（Hilbert space），这是一个内积空间，其上的向量可以用来表示系统的可能状态。对于一个单量子比特系统，这个希尔伯特空间是一个二维复数向量空间，通常与二维欧几里得空间中的向量空间相对应，尽管其“向量”实际上是复数的。

2. **基矢**: 为了完全描述希尔伯特空间中的任意向量（即系统的所有可能状态），需要选择一组基矢。对于一个单量子比特系统，最常用的基是所谓的“计算基”，它由两个正交的基矢组成：|0〉 和 |1〉。选择这个基之后，任何量子态都可以表示为这两个基矢的线性组合。

3. **归一化**: 状态向量需要满足归一化条件，意味着其模的平方代表该状态下找到量子系统的概率，总概率必须为1。因此，|0〉 和 |1〉 被标准化，使得它们的模平方均为1。

4. **|0〉 的具体定义**: 基于以上规则，态 |0〉 被定义为希尔伯特空间中表示量子比特处于“0”态的特定向量，并且通常取为 \([1, 0]\)（在实数表示时）或 \([1, 0]\)（在复数表示时，这里实际上也是实数，因为我们默认 |0〉 是实的）。这意味着如果测量该量子比特，我们得到结果 “0” 的概率为1，这是基矢本身的特性。

综上所述，|0〉 的向量表示 \([1, 0]\)（或更一般地，在多量子比特系统中作为直积的一部分）是由量子力学理论框架和对量子态进行数学描述的需求所规定的。

```python

```

```python
sim = Simulator('mqvector', 2)   #声明一个两比特的mqvector模拟器
sim                              #展示模拟器状态
```

    mqvector simulator with 2 qubits (little endian), dtype: mindquantum.complex128.
    Current quantum state:
    1¦00〉

在MindSpore Quantum中，我们可以在`mindquantum.simulator`模块导入模拟器。[Simulator](https://mindspore.cn/mindquantum/docs/zh-CN/master/simulator/mindquantum.simulator.Simulator.html#mindquantum.simulator.Simulator) 类可以接受四个参数：

- `backend`：所用到的模拟器名称，目前`mindquantum`支持`mqvector`、`mqvector_gpu`、`mqmatrix` 和 [NoiseBackend](https://mindspore.cn/mindquantum/docs/zh-CN/master/simulator/mindquantum.simulator.NoiseBackend.html#mindquantum.simulator.NoiseBackend) 作为后端进行模拟。
- `n_qubits`：模拟器所用到的比特数，也就是这里的2。
- `seed`：模拟器在运行随机性相关算法时的随机种子，默认为一个随机数，可以不用提供。
- `dtype`: 模拟器模拟时用到的数据类型。由于量子态为复数，因此模拟器当前支持 [mindquantum.complex64](https://mindspore.cn/mindquantum/docs/zh-CN/master/mindquantum.dtype.html) 的单精度模拟和 [mindquantum.complex128](https://mindspore.cn/mindquantum/docs/zh-CN/master/mindquantum.dtype.html) 的双精度模拟，默认值为[mindquantum.complex128](https://mindspore.cn/mindquantum/docs/zh-CN/master/mindquantum.dtype.html)。

通过模拟器的输出结果我们可以发现，这是一个`mqvector`的2比特模拟器，并且是little endian的。这里little endian的意思是，整个模拟器中，我们都是将比特序号小的比特放在量子态矢量的右边。接下来，输出还说明了模拟器当前所处的量子态是多少，且在模拟器初始化后，当前的量子态默认处于零态。注意，量子模拟器始终会维护一个内部的量子态，当我们作用量子门或者量子线路到模拟器上时，这个量子态会随即发生改变，而当我们只是想获取关于这个量子态的一些信息时，这个量子态则不会改变。这里就涉及到对量子模拟器的两类操作：

- 会改变量子态的操作，通常以`apply`开头，主要有如下几个
    - [apply_gate](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/simulator/mindquantum.simulator.Simulator.html#mindquantum.simulator.Simulator.apply_gate): 作用一个量子门到模拟器上
    - [apply_circuit](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/simulator/mindquantum.simulator.Simulator.html#mindquantum.simulator.Simulator.apply_circuit): 作用一个量子线路到模拟器上
    - [apply_hamiltonian](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/simulator/mindquantum.simulator.Simulator.html#mindquantum.simulator.Simulator.apply_hamiltonian): 将一个哈密顿量作用到模拟器上，注意，此后模拟器的量子态将不再是一个真的量子态
    - [set_qs](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/simulator/mindquantum.simulator.Simulator.html#mindquantum.simulator.Simulator.set_qs): 直接设置模拟器的当前量子态
    - [reset](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/simulator/mindquantum.simulator.Simulator.html#mindquantum.simulator.Simulator.reset): 重置模拟器的状态为|0〉态
- 不会改变量子态的操作，通常以`get`开头，主要有如下几个
    - [get_qs](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/simulator/mindquantum.simulator.Simulator.html#mindquantum.simulator.Simulator.get_qs): 获取模拟器的当前量子态
    - [get_expectation](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/simulator/mindquantum.simulator.Simulator.html#mindquantum.simulator.Simulator.get_expectation): 计算模拟器当前量子态关于某个观察量的期望值
    - [get_expectation_with_grad](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/simulator/mindquantum.simulator.Simulator.html#mindquantum.simulator.Simulator.get_expectation_with_grad): 跟上一个接口类似，只不过这个方法还会计算期望值关于参数化量子线路的梯度
    - [sampling](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/simulator/mindquantum.simulator.Simulator.html#mindquantum.simulator.Simulator.sampling): 在当前量子态下，对给定的量子线路进行采样

下面我们简单学习模拟器的基本操作。

## 作用量子门和量子线路

是的，量子模拟器如您所描述的，确实支持单独应用量子门以及后续构建量子线路再应用的灵活性。在量子计算中，这种操作模式非常常见，允许用户逐步构建和测试他们的量子算法或量子线路。

具体到您的代码示例中：

1. **单独应用量子门**:
   当您执行 `sim.apply_gate(H.on(0))` 时，您是在直接作用一个量子门（这里是Hadamard门）到模拟器当前维护的量子态上的特定量子比特（0号比特，根据小端序，这是右侧的比特）。这意味着模拟器立即更新了内部的量子态，以反映应用该量子门之后的状态。

2. **构建量子线路并应用**:
   在此之后，如果您想要构建一个更复杂的量子线路并应用到模拟器上，可以通过定义一个量子线路（如使用MindQuantum的`Circuit`类），在其中添加多个门操作，然后将整个线路应用到模拟器中。比如，您先创建了一个空的量子线路 `circ = Circuit()`，然后添加了Hadamard门和参数化的RY门，最后通过 `sim.apply_circuit(circ, pr={'a':某个值})` 来应用整个线路。这种方法允许您设计并一次性应用一连串精心安排的量子门操作。

这种设计模式的优势在于提供了高度的灵活性和模块化，使得用户可以根据需要逐步调试和优化他们的量子算法。可以在模拟器上直接尝试单个量子门的效果，理解其对量子态的影响，然后组合这些基本操作来构建更复杂的量子线路。

```python
sim = Simulator('mqvector', 2)    #声明一个2比特的mqvector模拟器
sim.apply_gate(H.on(0))           #作用一个Hadamard门到0号比特上
sim                               #输出量子模拟器的信息  ##我们都是将比特序号小的比特放在量子态矢量的右边
```

    mqvector simulator with 2 qubits (little endian), dtype: mindquantum.complex128.
    Current quantum state:
    √2/2¦00〉
    √2/2¦01〉

当你在具有小端序（little endian）的 `mqvector` 模拟器上对2比特系统应用一个 Hadamard 门到第0号比特上时，这个操作实际上改变了系统的量子态。Hadamard 门的作用是将输入的量子比特（如果是 |0〉 或 |1〉）转换到它们的叠加态，具体来说，Hadamard 门作用于 |0〉 会得到 \(\frac{1}{\sqrt{2}}(|0〉 + |1〉)\)。

开始时，系统的状态是 |00〉，用向量表示为：
\[
|00〉 = \begin{bmatrix} 1 \\ 0 \\ 0 \\ 0 \end{bmatrix}
\]

应用 Hadamard 门到第0号比特（小端序下，这是右侧的比特）后，系统的状态变为：
\[
\frac{1}{\sqrt{2}}(|00〉 + |01〉) = \frac{1}{\sqrt{2}}\left( \begin{bmatrix} 1 \\ 0 \\ 0 \\ 0 \end{bmatrix} + \begin{bmatrix} 0 \\ 0 \\ 1 \\ 0 \end{bmatrix} \right) = \begin{bmatrix} \frac{1}{\sqrt{2}} \\ 0 \\ \frac{1}{\sqrt{2}} \\ 0 \end{bmatrix}
\]

这与给出的描述相符：
\[
\sqrt{\frac{1}{2}}|00〉 + \sqrt{\frac{1}{2}}|01〉 = \sqrt{\frac{1}{2}}\begin{bmatrix} 1 \\ 0 \\ 0 \\ 0 \end{bmatrix} + \sqrt{\frac{1}{2}}\begin{bmatrix} 0 \\ 0 \\ 1 \\ 0 \end{bmatrix} = \begin{bmatrix} \sqrt{\frac{1}{2}} \\ 0 \\ \sqrt{\frac{1}{2}} \\ 0 \end{bmatrix}
\]

因此，经过Hadamard变换后的量子态向量表示为：
\[
\begin{bmatrix} \frac{1}{\sqrt{2}} \\ 0 \\ \frac{1}{\sqrt{2}} \\ 0 \end{bmatrix}
\]
这表示系统现在处于 |00〉 和 |01〉 的均匀叠加态，每个态的概率均为 \(\frac{1}{2}\)。

上面我们在量子模拟器的初态上作用了一个 [Hadamard](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/gates/mindquantum.core.gates.HGate.html) 门，并输出了演化过后的量子态。接下来我们生成一个参数化[量子线路](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/circuit/mindquantum.core.circuit.Circuit.html)，并将其作用到当前的量子态上。

```python
from mindquantum.core.circuit import Circuit   # 导入Circuit模块，用于搭建量子线路

circ = Circuit()                               #声明一个空的量子线路
circ += H.on(1)                                #向其中添加一个hadamard门，并作用到1号比特上
circ += RY('a').on(0)                          #向其中添加一个参数化的RY门，并作用到0号比特上
circ.svg()                                     #绘制SVG格式的量子线路图片
```

    
    

```python
sim.apply_circuit(circ, pr={'a': 1.234})  #作用一个量子线路，当线路是一个参数化量子线路时，我们还需要提供参数值。
sim
```

    mqvector simulator with 2 qubits (little endian), dtype: mindquantum.complex128.
    Current quantum state:
    0.11851349145283663¦00〉
    0.6971044056263442¦01〉
    0.11851349145283663¦10〉
    0.6971044056263442¦11〉

```python

```

```python

```

```python
sim = Simulator('mqvector', 2)   #声明一个两比特的mqvector模拟器
sim                              #展示模拟器状态
# sim = Simulator('mqvector', 2)    #声明一个2比特的mqvector模拟器
# sim.apply_gate(H.on(0))           #作用一个Hadamard门到0号比特上
# sim                               #输出量子模拟器的信息  ##我们都是将比特序号小的比特放在量子态矢量的右边
```

    mqvector simulator with 2 qubits (little endian), dtype: mindquantum.complex128.
    Current quantum state:
    1¦00〉

```python
from mindquantum.core.circuit import Circuit   # 导入Circuit模块，用于搭建量子线路

circ = Circuit()                               #声明一个空的量子线路
circ += H.on(1)                                #向其中添加一个hadamard门，并作用到1号比特上
circ += RY('a').on(0)                          #向其中添加一个参数化的RY门，并作用到0号比特上
circ.svg()  
```

    
    

```python
sim.apply_circuit(circ, pr={'a': 1.234})  #作用一个量子线路，当线路是一个参数化量子线路时，我们还需要提供参数值。
sim
```

    mqvector simulator with 2 qubits (little endian), dtype: mindquantum.complex128.
    Current quantum state:
    0.5767289458818002¦00〉
    0.4091255589450109¦01〉
    0.5767289458818002¦10〉
    0.4091255589450109¦11〉

```python

```

要达到这个量子态，可以通过一系列精心设计的量子门操作来实现。给定的量子态是一个两量子比特系统的态，每个基态的系数代表了该态出现的概率幅。具体来说，该量子态可以写作：

\[
|\psi〉 = 0.11851349145283663|00〉 + 0.6971044056263442|01〉 + 0.11851349145283663|10〉 + 0.6971044056263442|11〉
\]

这个态的特征是，|01〉 和 |11〉 状态的概率幅相同且较大（约为0.697），而 |00〉 和 |10〉 的概率幅相同且较小（约为0.118）。这意味着量子系统在 |01〉 和 |11〉 状态上有着较高的概率分布，而 |00〉 和 |10〉 状态的概率相对较低。

要使用MindQuantum框架并遵循您的指令来模拟这个过程，我们可以逐步构建并分析一个量子线路，以达到您最初提到的目标量子态。下面是一个详细的解释，包括如何使用MindQuantum的`Circuit`来构建线路，并理解它如何影响量子态矢量。

### 第一步：初始化模拟器和量子线路

- 首先，您创建了一个具有2个量子比特的`mqvector`模拟器。这允许我们模拟最多2个量子比特的状态，且按照您的说明，小端序下比特0在右边。

### 第二步：应用Hadamard门到第0号比特

- 使用`sim.apply_gate(H.on(0))`，你实际上是在将一个Hadamard门应用于第一个量子比特（按照小端序，这是右侧的比特）。Hadamard门将把初始态 |0〉 转换为 \( \frac{1}{\sqrt{2}}(|0〉 + |1〉) \)，即在 |0〉 和 |1〉 之间创造了一个均匀的叠加态。因此，如果你从 |00〉 开始，应用H门后，你将得到：
  \[
  |\psi_1〉 = \frac{1}{\sqrt{2}}(|00〉 + |10〉)
  \]

### 第三步：构建并应用量子线路

- 接下来，通过导入`Circuit`模块并定义一个空的量子线路，您开始构建一个更复杂的量子操作序列。
  
- 向线路中添加`H.on(1)`操作，意味着对第二个量子比特（小端序下的比特1，实际位置在左边）应用Hadamard门。由于第二个比特原本处于 |0〉 状态，应用Hadamard门之后，它也会变为 \( \frac{1}{\sqrt{2}}(|0〉 + |1〉) \)。但因为这个操作在H门已经作用于第一个比特之后，我们需要考虑两比特的整体叠加。

- 随后，添加了一个参数化的`RY('a')`门作用于第一个比特。`RY`门是一种旋转门，它绕Y轴旋转一个角度`a`。这个操作可以用来调整第一个比特的相位，从而改变整体量子态的系数。具体到这个场景，选择合适的`a`值是为了使得最终态的系数满足特定的比例要求。

### 计算过程的向量说明

假设`RY('a')`门应用后，我们得到了正确的参数`a`，使得最终态能够匹配目标态。那么，整体计算过程可以用以下步骤概括：

1. **初始态**：\[|00〉 = \begin{pmatrix} 1 \\ 0 \\ 0 \\ 0 \end{pmatrix}\]

2. **应用Hadamard门到比特0**：\[H_0 \rightarrow \frac{1}{\sqrt{2}}(|00〉 + |10〉) = \begin{pmatrix} \frac{1}{\sqrt{2}} \\ 0 \\ \frac{1}{\sqrt{2}} \\ 0 \end{pmatrix}\]

3. **应用Hadamard门到比特1（在Circuit中）**：这一步实际上是将整个系统置于一个更加复杂的叠加态，但由于我们直接从第二步转移到构建电路，这里需要明确，如果在Hadamard门作用于第二个比特后不考虑第一个比特的改变，直接应用会得到 \(\frac{1}{2}(|00〉 + |01〉 + |10〉 + |11〉)\)。但正确的是考虑两步联合效应，即应用`RY('a')`前后的状态变化。

4. **应用RY('a')到比特0**：这一步是关键，通过选择合适的`a`值，我们可以调整系数，使得最终态为 \[0.11851349145283663|00〉 + 0.6971044056263442|01〉 + 0.11851349145283663|10〉 + 0.6971044056263442|11〉\]。

为了准确找到`a`的值，通常需要通过解析计算或数值优化，确保应用`RY(a)`后的量子态与目标态匹配。在MindQuantum中，你可以直接运行模拟并优化参数来达到特定的目标态。这里的关键在于理解`RY(a)`的具体参数化形式及其对量子态的影响，然后通过模拟器执行这些操作并观察结果，最终调整参数直到达到目标概率幅。

理解这个过程的关键在于认识到量子态的演化是基于量子比特之间的相互作用以及每一步操作对整个系统状态的影响。当我们对一个多量子比特系统应用操作时，我们必须考虑操作对系统整体状态矢量的影响，而不是孤立地看待每个比特的变换。下面我将详细解释这个联合效应。

### 初始设定

假设我们从两量子比特的基态 \(|00\rangle\) 开始，这是一个直积态，可以表示为向量 \(\begin{pmatrix}1 \\ 0 \\ 0 \\ 0\end{pmatrix}\) 在计算基底下。

### 第一步：对第一个量子比特应用Hadamard门

如之前所述，这一步将第一个量子比特置于一个叠加态，得到的态为 \(\frac{1}{\sqrt{2}}(|00\rangle + |10\rangle)\)，对应的向量是 \(\begin{pmatrix}\frac{1}{\sqrt{2}} \\ 0 \\ \frac{1}{\sqrt{2}} \\ 0\end{pmatrix}\)。

### 第二步：理论上的误解

如果我们错误地忽略了第一步对第二个量子比特应用Hadamard门时第一个比特已经被改变的事实，而直接考虑两个独立Hadamard变换的效果，那么理论上我们会认为两个独立的Hadamard门（分别作用于两个不同的未改变的 |0〉 状态）会将整个系统带入完全均匀的叠加态 \(|00\rangle + |01\rangle + |10\rangle + |11\rangle\)，这对应于向量 \(\frac{1}{2}\begin{pmatrix}1 \\ 1 \\ 1 \\ 1\end{pmatrix}\)。

### 正确的理解：联合效应

但实际上，当我们在第二个量子比特上应用Hadamard门时，第一个比特已经处于叠加态。这意味着我们需要考虑的是初始态经过第一个Hadamard门变换后的整体状态再进行变换，而不是简单地将两个独立的Hadamard变换效果相加。

- 正确的顺序应该是：首先应用Hadamard门到第一个比特，得到 \(\frac{1}{\sqrt{2}}(|00\rangle + |10\rangle)\)。
- 然后，对第二个比特应用Hadamard门。此时，由于第一个比特已经是叠加态，应用Hadamard门到第二个比特相当于同时对两个比特的所有可能组合进行变换。正确的计算应考虑两比特的联合状态，即 \(H_1 \otimes H_2\)（这里的 \(\otimes\) 表示张量积），作用于初始态 \(|00\rangle\)。

### 应用RY门的考虑

在上述基础上，再应用参数化的RY('a')门到第一个比特，实际上是在调整该比特的相位，影响整个系统的叠加权重。这意味着最终态不仅取决于是否处于叠加态，还取决于各个叠加态之间的相对相位，这是由RY门的参数\(a\)决定的。

因此，当你正确地考虑这些联合效应，即第一个比特的Hadamard门应用，紧接着第二个比特的Hadamard门，最后是第一个比特上的RY('a')门，你会得到一个精确反映所有这些操作累积影响的最终量子态。这个过程展示了量子计算中操作顺序和量子态叠加原理的重要性。

具体计算过程涉及将每个量子门操作映射为矩阵运算，然后将这些运算依次应用于初始量子态的向量表示。让我们分步解析这个过程，包括之前的Hadamard门应用和之后的Circuit操作，特别是其中的Hadamard门和参数化的RY门。

### 初始化态
假设初始态是 \(|00\rangle\)，其向量表示为：
\[
\begin{bmatrix} 1 \\ 0 \\ 0 \\ 0 \end{bmatrix}
\]

### 第一部分：直接应用Hadamard门到0号比特
1. **Hadamard门的矩阵表示**：对于单量子比特操作，Hadamard门的矩阵是：
\[
H = \frac{1}{\sqrt{2}}\begin{bmatrix} 1 & 1 \\ 1 & -1 \end{bmatrix}
\]
由于我们是在一个两量子比特系统上操作，Hadamard门实际上作用于系统的子空间，其完整操作涉及将Hadamard门与单位矩阵相乘形成一个4x4的矩阵。但由于我们仅作用于第一个比特（在小端序下为右侧比特），实际操作是：
\[
H \otimes I = \frac{1}{\sqrt{2}}\begin{bmatrix} 1 & 1 \\ 1 & -1 \end{bmatrix} \otimes \begin{bmatrix} 1 & 0 \\ 0 & 1 \end{bmatrix} = \frac{1}{\sqrt{2}}\begin{bmatrix} 1 & 0 & 1 & 0 \\ 0 & 1 & 0 & 1 \\ 1 & 0 & -1 & 0 \\ 0 & 1 & 0 & -1 \end{bmatrix}
\]
应用这个操作到初始态上：
\[
\frac{1}{\sqrt{2}}\begin{bmatrix} 1 & 0 & 1 & 0 \\ 0 & 1 & 0 & 1 \\ 1 & 0 & -1 & 0 \\ 0 & 1 & 0 & -1 \end{bmatrix} \begin{bmatrix} 1 \\ 0 \\ 0 \\ 0 \end{bmatrix} = \begin{bmatrix} \frac{1}{\sqrt{2}} \\ 0 \\ \frac{1}{\sqrt{2}} \\ 0 \end{bmatrix}
\]

### 第二部分：构建并应用量子线路
1. **添加Hadamard门到1号比特**：再次应用Hadamard门，这次是针对第二个比特（小端序下为左侧比特），我们需要将Hadamard门作用在第一个位置（对应第二个比特），而保持第一个比特不变，即应用 \(I \otimes H\)。但正确的处理是考虑两比特的共同变换，所以实际操作矩阵是：
\[
(I \otimes H) = \begin{bmatrix} 1 & 0 \\ 0 & 1 \end{bmatrix} \otimes \frac{1}{\sqrt{2}}\begin{bmatrix} 1 & 1 \\ 1 & -1 \end{bmatrix} = \frac{1}{\sqrt{2}}\begin{bmatrix} 1 & 1 & 0 & 0 \\ 1 & -1 & 0 & 0 \\ 0 & 0 & 1 & 1 \\ 0 & 0 & 1 & -1 \end{bmatrix}
\]
然而，由于我们已经在第一步对第一个比特进行了变换，此处的正确处理是理解两步操作的综合效果，而不是简单地再次应用Hadamard门。

2. **应用RY('a')到0号比特**：参数化的RY门操作涉及在Y轴上旋转一定角度，其矩阵形式为：
\[
RY(\theta) = \begin{bmatrix} \cos(\theta/2) & -\sin(\theta/2) \\ \sin(\theta/2) & \cos(\theta/2) \end{bmatrix}
\]
在两量子比特系统中，这个操作实际上会影响整个系统，但重点是第一个比特。因此，完整的操作应考虑如何将RY门应用于第一个比特的同时保持第二个比特状态的正确表示，这通常涉及对整个系统状态的变换矩阵的构造。正确的做法是构造一个控制操作，但在这里，简单理解为对第一个比特应用RY门，然后考虑其对整体态的影响。

### 综合考虑
实际的计算过程需要考虑上述所有步骤的连贯性，特别是参数化的RY门如何与之前的Hadamard门操作相结合。直接从初始态通过Hadamard门变换到特定的叠加态，然后找到合适的RY门参数`a`，使得最终态的系数满足特定比例要求，这涉及到复杂的矩阵运算和参数优化过程。

因此，正确的计算过程需要按照实际的量子线路逻辑，逐步应用每个门操作的矩阵变换，最终得到的目标态应为：
\[
0.11851349145283663|00〉 + 0.6971044056263442|01〉 + 0.11851349145283663|10〉 + 0.6971044056263442|11〉
\]
为了达到这个特定的态，必须通过精确的门操作序列和参数调整来实现。直接的计算步骤需借助于量子计算软件或工具来完成，尤其是对于参数化的门，需要迭代或解析方法来找到合适的参数值`a`。

在上面的代码中，我们先生成了一个参数化量子线路`circ`，随后我们将其作用到量子模拟器上，并通过传入字典的方式，将参数`a`设置为`1.234`。最后输出量子模拟器演化出来的量子态。

## 设置并获取模拟器状态

我们使用 [get_qs(ket=False)](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/simulator/mindquantum.simulator.Simulator.html#mindquantum.simulator.Simulator.get_qs) 查看当前模拟器的状态，
参数`ket`是一个`bool`类型的数，它决定了当前模拟器的状态是否以ket字符串的形式返回，`ket=False`时是以`numpy.ndarray`形式，`ket=True`时是以ket字符串形式。默认`ket=False`。

```python
print(sim.get_qs())  #查看模拟器状态，以numpy.ndarray形式返回结果
```

    [0.57672895+0.j 0.40912556+0.j 0.57672895+0.j 0.40912556+0.j]

```python
print(sim.get_qs(True))  #查看模拟器状态，以ket形式返回结果
```

    0.5767289458818002¦00〉
    0.4091255589450109¦01〉
    0.5767289458818002¦10〉
    0.4091255589450109¦11〉

在实际写代码过程中，我们常常需要将模拟器指定一个初始态开始演化，这个操作可以使用 [set_qs()](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/simulator/mindquantum.simulator.Simulator.html#mindquantum.simulator.Simulator.set_qs) 实现。

例如，我们希望模拟器状态为

$$
\frac{\sqrt{3}}{3}|00〉+\frac{\sqrt{6}}{3}|11〉
$$

第一步：我们计算出目标状态的向量形式：

$$
\frac{\sqrt{3}}{3}|00〉+\frac{\sqrt{6}}{3}|11〉 =\frac{\sqrt{3}}{3}\times
\left(
\begin{array}{l}
1\\
0
\end{array}
\right)
\otimes
\left(
\begin{array}{l}
1\\
0
\end{array}
\right)+
\frac{\sqrt{6}}{3}\times
\left(
\begin{array}{l}
0\\
1
\end{array}
\right)\otimes
\left(
\begin{array}{l}
0\\
1
\end{array}
\right)= \frac{\sqrt{3}}{3}\times
\left(
\begin{array}{l}
1\\
0\\
0\\
0
\end{array}
\right)+
\frac{\sqrt{6}}{3}\times
\left(
\begin{array}{l}
0\\
0\\
0\\
1
\end{array}
\right)=
\left(
\begin{array}{l}
\frac{\sqrt{3}}{3}\\
0\\
0\\
\frac{\sqrt{6}}{3}
\end{array}
\right)
$$

第二步：我们将这个向量使用 [set_qs()](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/simulator/mindquantum.simulator.Simulator.html#mindquantum.simulator.Simulator.set_qs) 赋值给模拟器，让其作为模拟器的状态：

```python
np.array([3**0.5, 0, 0, 6**0.5])
```

    array([1.73205081, 0.        , 0.        , 2.44948974])

```python
sim.set_qs(np.array([3**0.5, 0, 0, 6**0.5]))        #设置模拟器状态，无需归一化
print(sim.get_qs(True))                             #查看模拟器状态
```

    0.5773502691896258¦00〉
    0.816496580927726¦11〉

通过 [get_qs()](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/simulator/mindquantum.simulator.Simulator.html#mindquantum.simulator.Simulator.get_qs) 查看模拟器状态可以发现，当前模拟器状态即为我们希望设置的$\frac{\sqrt{3}}{3}|00〉+\frac{\sqrt{6}}{3}|11〉$。

在实际编程过程中，我们常常需要多次模拟电路，通过多开模拟器的方式会导致内存占用非常大，我们可以通过现有模拟器复位的方式来复用模拟器，从而减少内存消耗。

我们使用 [reset()](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/simulator/mindquantum.simulator.Simulator.html#mindquantum.simulator.Simulator.reset) 来复位模拟器：

```python
sim.reset()          #复位模拟器
print(sim.get_qs())  #查看模拟器状态
```

    [1.+0.j 0.+0.j 0.+0.j 0.+0.j]

可以发现，当前模拟器被复位成了初始的$1|00〉$态，相当于一个全新的模拟器。

因此，我们可以根据自身所需的量子初态，设置对应的量子模拟器，并运行自定义的量子线路。赶紧动手运行你构造出的的第一个量子线路吧！

## [量子线路采样](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/simulator/mindquantum.simulator.Simulator.html#mindquantum.simulator.Simulator.sampling)

线路采样是指对量子线路执行多次模拟测量，统计测量出各种结果出现的频次。**采样不会改变量子线路中的状态**。

[sampling(circuit, pr=None, shots=1, seed=None)](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/simulator/mindquantum.simulator.Simulator.html#mindquantum.simulator.Simulator.sampling) 是`MindSpore Quantum`中提供的对模拟器进行线路采样方法，它接受四个参数：

- `circuit (Circuit)`：希望进行采样的[量子线路](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/circuit/mindquantum.core.circuit.Circuit.html)，注意，该线路中必须包含至少一个测量操作（即采样点）。
- `pr (Union[None, dict, ParameterResolver])`：[parameter resolver](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/core/parameterresolver/mindquantum.core.parameterresolver.ParameterResolver.html)，当 `circuit`是含参线路时，需要给出参数的值。
- `shots (int)`：采样的次数，默认为1。
- `seed`：采样时的随机种子，默认为一个随机数，可以不用提供。

```python
# 不含参线路采样：
from mindquantum.core.gates import Measure  # 引入测量门

circ = Circuit()                            # 初始化量子线路
circ += H.on(0)                             # H门作用在第0位量子比特
circ += X.on(1, 0)                          # X门作用在第1位量子比特且受第0位量子比特控制
circ += Measure('q0').on(0)                 # 在0号量子比特作用一个测量，并将该测量命名为'q0'
circ += Measure('q1').on(1)                 # 在1号量子比特作用一个测量，并将该测量命名为'q1'
circ.svg()                                  # 绘制SVG格式的量子线路图片
```

    
    

```python
sim.reset()
result = sim.sampling(circ, shots=1000)  # 对上面定义的线路采样1000次  统计测量出各种结果出现的频次
result
```

<pre style="white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace"></pre>

<pre style="white-space: pre;"><span style="color: #808000; text-decoration-color: #808000">shots: </span><span style="color: #008080; text-decoration-color: #008080; font-weight: bold">1000</span>
<span style="color: #808000; text-decoration-color: #808000">Keys: q1 q0│</span><span style="color: #008080; text-decoration-color: #008080; font-weight: bold">0.00</span><span style="color: #808000; text-decoration-color: #808000">   </span><span style="color: #008080; text-decoration-color: #008080; font-weight: bold">0.128</span><span style="color: #808000; text-decoration-color: #808000">       </span><span style="color: #008080; text-decoration-color: #008080; font-weight: bold">0.257</span><span style="color: #808000; text-decoration-color: #808000">       </span><span style="color: #008080; text-decoration-color: #008080; font-weight: bold">0.385</span><span style="color: #808000; text-decoration-color: #808000">       </span><span style="color: #008080; text-decoration-color: #008080; font-weight: bold">0.513</span><span style="color: #808000; text-decoration-color: #808000">       </span><span style="color: #008080; text-decoration-color: #008080; font-weight: bold">0.641</span>
<span style="color: #808000; text-decoration-color: #808000">───────────┼───────────┴───────────┴───────────┴───────────┴───────────┴</span>
<span style="color: #808000; text-decoration-color: #808000">         </span><span style="color: #008080; text-decoration-color: #008080; font-weight: bold">00</span><span style="color: #808000; text-decoration-color: #808000">│▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓</span>
<span style="color: #808000; text-decoration-color: #808000">           │</span>
<span style="color: #808000; text-decoration-color: #808000">         </span><span style="color: #008080; text-decoration-color: #008080; font-weight: bold">11</span><span style="color: #808000; text-decoration-color: #808000">│▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒</span>
<span style="color: #808000; text-decoration-color: #808000">           │</span>
<span style="color: #808000; text-decoration-color: #808000; font-weight: bold">{</span><span style="color: #008000; text-decoration-color: #008000">'00'</span><span style="color: #808000; text-decoration-color: #808000">: </span><span style="color: #008080; text-decoration-color: #008080; font-weight: bold">513</span><span style="color: #808000; text-decoration-color: #808000">, </span><span style="color: #008000; text-decoration-color: #008000">'11'</span><span style="color: #808000; text-decoration-color: #808000">: </span><span style="color: #008080; text-decoration-color: #008080; font-weight: bold">487</span><span style="color: #808000; text-decoration-color: #808000; font-weight: bold">}</span>
</pre>

观察到只有 |00〉 和 |11〉 两种结果，是因为量子线路和门操作的特定组合，加上可能的量子纠缠效应，使得系统在最终测量时倾向于塌缩到这两个特定的计算基态上。为了看到 |01〉 和 |10〉，可能需要重新设计线路或调整参数来增加这些态的权重。

MindSpore Quantum还提供了采样结果绘制SVG图的功能：

```python
result.svg()  # 打印出测量结果的SVG格式
```

    
    

我们可以看到，采样1000中，'00'出现了508次，'11'出现了492次（在你运行时，结果可能会不同）。我们搭建的线路实际上制备出了一个贝尔态$\frac{\sqrt{2}}{2}|00〉+\frac{\sqrt{2}}{2}|11〉$。直观上，我们可以看到对该状态进行测量得到'00'的概率为$\frac{1}{2}$,得到'11'的概率为$\frac{1}{2}$，采样结果符合概率，细微的误差是由模拟器噪声导致。

在量子计算中，当我们谈论制备出一个贝尔态，如 \(\frac{\sqrt{2}}{2}|00〉+\frac{\sqrt{2}}{2}|11〉\)，这意味着我们得到了一个特殊的两量子比特状态，其中两个量子比特处于完全纠缠之中。这个状态的有趣之处在于，无论何时测量这对纠缠比特，如果你发现一个比特处于某种状态（比如 |0〉 或 |1〉），另一比特将会立刻确定地处于相同的状态。因此，测量结果要么是 |00〉，要么是 |11〉，且每种结果出现的概率都是 \(\frac{1}{2}\)。

采样结果与理论预期相符的解释如下：

1. **概率解释**：在理想情况下，贝尔态 \(\frac{\sqrt{2}}{2}|00〉+\frac{\sqrt{2}}{2}|11〉\) 显示了两个状态的完全等概率性。这意味着如果你进行大量重复实验（在这个案例中是1000次采样），理论上你应该大约一半时间观察到 |00〉，另一半时间观察到 |11〉。具体到你的结果，'00' 出现了508次，'11' 出现了492次，这非常接近理论上的 \(\frac{1}{2}\) 概率，表明制备的量子态与预期的贝尔态一致。

2. **噪声和误差**：实际的量子计算和模拟中，由于硬件的不完美、环境干扰、以及模拟过程中的近似等因素，采样结果通常会与理想情况有细微偏差。这些偏差可以被视为“噪声”。在你给出的例子中，'00' 和 '11' 的出现次数略有差异，正是这种噪声的表现。模拟器噪声是指在模拟量子系统时，由于算法或实现的限制，模拟结果与理想无噪情况下的理论预测之间存在的微小差异。

3. **统计波动**：即使在理想的无噪声环境下，由于采样是随机过程，也存在一定的统计波动。1000次采样虽然数量可观，但仍然不足以完全消除随机性带来的波动。长期平均来看，随着采样次数增加到非常大的数量级，'00' 和 '11' 出现的频率会越来越接近理论上的 \(\frac{1}{2}\)，但任何有限次数的采样都可能显示出轻微的偏离。

综上所述，观察到的采样结果与贝尔态的理论概率相符，并且轻微的偏差可归因于模拟过程中的固有噪声和有限采样带来的统计波动。这是量子计算和模拟中常见的现象，也是理解实验结果时需要考虑的因素。

```python
# 含参线路采样：
para_circ = Circuit()             # 初始化量子线路
para_circ += H.on(0)              # H门作用在第0位量子比特
para_circ += X.on(1, 0)           # X门作用在第1位量子比特且受第0位量子比特控制
para_circ += RY('theta').on(1)    # RY(theta)门作用在第2位量子比特
para_circ += Measure('q0').on(0)   # 在0号量子比特作用一个测量，并将该测量命名为'q0'
para_circ += Measure('q1').on(1)  # 在1号量子比特作用一个测量，并将该测量命名为'q1'
para_circ.svg()                   # 绘制SVG格式的量子线路图片
```

    
    

```python
sim.reset()
result = sim.sampling(para_circ, {'theta': 0}, shots=1000)  # 将上面定义的线路参数'theta'赋值为0采样1000次
result.svg()
```

    
    

我们可以看到，采样结果中'00'出现了517次，'11'出现了483次（在你运行时，结果可能会不同）。事实上把RY门参数赋值为0，它即为我们熟悉的I门，相当于不对线路做任何操作，因此该采样线路与上面不含参线路本质是同一个，可以观察到二次采样结果几乎相同，符合预期结果。

## 模拟器支持情况

当前 MindSpore Quantum 支持多种模拟器，具体情况如下：

|模拟器名称|特性|是否支持GPU|单精度支持|多精度支持|
|--|--|--|--|--|
|`mqvector`|全振幅模拟器|❌|✅|✅|
|`mqvector_gpu`|GPU版全振幅模拟器|✅|✅|✅|
|`mqmatrix`|密度矩阵模拟器|❌|✅|✅|
|[NoiseBackend](https://mindspore.cn/mindquantum/docs/zh-CN/master/simulator/mindquantum.simulator.NoiseBackend.html#mindquantum.simulator.NoiseBackend)|噪声模拟器，教程请参考：[噪声模拟器](https://mindspore.cn/mindquantum/docs/zh-CN/master/middle_level/noise_simulator.html)|✅|✅|✅|

> 请注意，`mqvector_gpu`后端仅支持在CUDA 11及以上版本的环境中运行。

## 模拟器的选择

我们知道，量子态的维度是随着比特数的增多而指数增加的，因此模拟大比特量子系统时，需要的物理内存将急剧增加。下面，我们给出不同比特下，存储一个全振幅量子态所需要的内存空间：

|比特数|mindquantum.complex128|mindquantum.complex64|
|--|--|--|
|6|1kB|0.5kB|
|16|1MB|0.5MB|
|26|1GB|0.5GB|
|30|16GB|8GB|
|36|1TB|0.5TB|
|40|16TB|8TB|
|46|1PB|0.5PB|

由此可见，在模拟大比特系统时，我们可以考虑使用单精度类型来减小内存占用量。在 MindSpore Quantum 中，我们可以通过 `dtype` 来方便的修改模拟器的数据类型：

```python
import mindquantum as mq
from mindquantum.simulator import Simulator

sim = Simulator('mqvector', 2, dtype=mq.complex64)
print(sim)
```

    mqvector simulator with 2 qubits (little endian), dtype: mindquantum.complex64.
    Current quantum state:
    1¦00〉

下面我们给出一些经验规则，帮助大家来合理的选择不同的模拟器：

- 量子系统小于8比特时：`mqvector`。在小比特时，CPU反而会比GPU运行快速。
- 量子系统大于8比特时：`mqvector_gpu`。在大比特时，GPU将会发挥其并行运算优势。
- 混态模拟时：`mqmatrix`。`mqmatrix`是密度矩阵模拟器，因此支持混态系统的模拟。
- 量子系统含噪声时：[NoiseBackend](https://mindspore.cn/mindquantum/docs/zh-CN/master/simulator/mindquantum.simulator.NoiseBackend.html#mindquantum.simulator.NoiseBackend)。通过该模拟器，我们可以方便的往线路中添加不同的量子信道，达到对噪声系统的模拟。
- 当进行量子化学模拟时：`mindquantum.complex128`。量子化学模拟需要模拟基态能量达到化学精度，因此建议用双精度类型。
- 当进行量子机器学习时：`mindquantum.complex64`。机器学习类任务对精度要求不敏感，因此建议用单精度类型。

想进一步学习如何对量子线路做测量操作，想了解采样结果分布的理论解释，请点击：[量子测量教程](https://www.mindspore.cn/mindquantum/docs/zh-CN/master/beginner/quantum_measurement.html)。

```python
from mindquantum.utils.show_info import InfoTable

InfoTable('mindquantum', 'scipy', 'numpy')
```

<table border="1">
  <tr>
    <th>Software</th>
    <th>Version</th>
  </tr>
<tr><td>mindquantum</td><td>0.9.11</td></tr>
<tr><td>scipy</td><td>1.9.3</td></tr>
<tr><td>numpy</td><td>1.24.2</td></tr>
<tr>
    <th>System</th>
    <th>Info</th>
</tr>
<tr><td>Python</td><td>3.9.11</td></tr><tr><td>OS</td><td>Linux x86_64</td></tr><tr><td>Memory</td><td>261.99 GB</td></tr><tr><td>CPU Max Thread</td><td>64</td></tr><tr><td>Date</td><td>Tue Jul  2 17:26:14 2024</td></tr>
</table>

```python

```