diff --git a/images/CC_U_decomposition.png b/images/CC_U_decomposition.png
new file mode 100644
index 0000000000000000000000000000000000000000..ec2ff60c3cb6418df520b282be8d5bdf51dc54a5
Binary files /dev/null and b/images/CC_U_decomposition.png differ
diff --git a/images/cnot_equivalent.png b/images/cnot_equivalent.png
new file mode 100644
index 0000000000000000000000000000000000000000..e7acb130cbb1354c5a92b4ff6ac84ee9dd4dd70c
Binary files /dev/null and b/images/cnot_equivalent.png differ
diff --git a/images/cnot_gate.png b/images/cnot_gate.png
new file mode 100644
index 0000000000000000000000000000000000000000..bd03dac308408d6141de5c6a0f1b1553769d232e
Binary files /dev/null and b/images/cnot_gate.png differ
diff --git a/images/deferred_measurement.png b/images/deferred_measurement.png
new file mode 100644
index 0000000000000000000000000000000000000000..ee94a829da9c2fb5afa6d4368cacc389a55fdde1
Binary files /dev/null and b/images/deferred_measurement.png differ
diff --git a/images/measurement.png b/images/measurement.png
new file mode 100644
index 0000000000000000000000000000000000000000..bf39a232edccafa2569b31e22c9701a92417b0b8
Binary files /dev/null and b/images/measurement.png differ
diff --git a/images/multiple_CU_decomposition.png b/images/multiple_CU_decomposition.png
new file mode 100644
index 0000000000000000000000000000000000000000..d2bf49a09a5ff276eca5f9649f40fc595d757fe6
Binary files /dev/null and b/images/multiple_CU_decomposition.png differ
diff --git a/images/swap_gate.png b/images/swap_gate.png
new file mode 100644
index 0000000000000000000000000000000000000000..764074a01a79981aeab47678950d8df2e062e659
Binary files /dev/null and b/images/swap_gate.png differ
diff --git a/lecture11.ipynb b/lecture11.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..8f51387c9c10b8e84dc9b6c2138b1fd2f4ed4404
--- /dev/null
+++ b/lecture11.ipynb
@@ -0,0 +1,241 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Lecture 11\n",
+ "\n",
+ "## 测量\n",
+ "\n",
+ "从量子计算的角度来看,量子测量通常被认为是沿着计算基矢的投影测量。电路图中的测量动作可以表示如下:\n",
+ "\n",
+ "\n",
+ "\n",
+ "测量前的单行表示一个量子比特,测量后的双线表示经典比特。\n",
+ "\n",
+ "**推迟测量原理(deferred measurement principle)**\n",
+ "\n",
+ "对于一个用量子电路来描述的量子计算过程,中间的测量步骤总可以找到一种等价的方式移到线路的末端,而不影响测量结果的概率分布。如果中间过程中的测量结果被用于该电路的某些阶段,则在推迟测量操作的时候,经典的条件运算可以被条件量子运算代替。\n",
+ "\n",
+ "以 Lecture 10 中量子隐形传态的电路为例:\n",
+ "\n",
+ "\n",
+ "\n",
+ "以下电路为应用推迟测量原理后的等价电路:\n",
+ "\n",
+ "\n",
+ "\n",
+ "在原本的电路中,测量前的量子态$|\\psi_2\\rangle$为\n",
+ "\n",
+ "$$\n",
+ "|\\psi_2\\rangle = \\frac{1}{2}(|00\\rangle|\\psi\\rangle +|01\\rangle X|\\psi\\rangle + |10\\rangle Z|\\psi\\rangle + |11\\rangle ZX|\\psi\\rangle)\n",
+ "$$\n",
+ "\n",
+ "改为执行受控操作后量子态变为\n",
+ "\n",
+ "$$\n",
+ "|\\psi^{new}_2\\rangle = \\frac{1}{2}(|00\\rangle|\\psi\\rangle +|01\\rangle |\\psi\\rangle + |10\\rangle |\\psi\\rangle - |11\\rangle |\\psi\\rangle)\n",
+ "$$\n",
+ "\n",
+ "此外,还存在着*隐式测量原理(implicit measurement)*,这意味着不需要测量最后的量子比特。\n",
+ "\n",
+ "用 MindQuantum 验证以上等价电路同样可以实现量子隐形传态:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "psi = [0.81732835 0.57617216]\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": "
",
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from mindquantum.core.gates import X, H, Z, Measure\n",
+ "from mindquantum.core.circuit import Circuit\n",
+ "from mindquantum.simulator import Simulator\n",
+ "import numpy as np\n",
+ "\n",
+ "psi = np.random.rand(2)\n",
+ "psi = psi / np.linalg.norm(psi)\n",
+ "print(f\"psi = {psi}\")\n",
+ "bell = np.array([1, 0, 0, 1]) / np.sqrt(2)\n",
+ "init = np.kron(bell, psi)\n",
+ "\n",
+ "sim = Simulator(\"projectq\", 3)\n",
+ "sim.set_qs(init)\n",
+ "\n",
+ "circ = Circuit()\n",
+ "circ += X.on(1, 0)\n",
+ "circ += H.on(0)\n",
+ "circ.barrier(False)\n",
+ "circ += X.on(2, 1)\n",
+ "circ += Z.on(2, 0)\n",
+ "circ += Measure().on(0)\n",
+ "circ += Measure().on(1)\n",
+ "\n",
+ "circ.svg()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "0.8173283543192481¦011⟩\n",
+ "0.5761721628348514¦111⟩\n"
+ ]
+ }
+ ],
+ "source": [
+ "sim.apply_circuit(circ)\n",
+ "print(sim.get_qs(ket=True))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "可以看到,q0的态$|\\psi\\rangle$已经成功地传送给q2。"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**关于量子隐形传态的讨论**\n",
+ "\n",
+ "回想一下,量子隐形传态的量子电路的主要部分实际上是贝尔态创建电路的逆过程,我们可以通过将贝尔态投影到前两个量子比特来得出相同的结果。明确地说,让我们考虑 00 的情况,可以写出\n",
+ "\n",
+ "$$\n",
+ "|\\psi\\rangle|B_{00}\\rangle=\\frac{1}{\\sqrt{2}}(|\\psi,0\\rangle|0\\rangle+|\\psi,1\\rangle|1\\rangle)\n",
+ "$$\n",
+ "\n",
+ "其中有$|\\psi\\rangle\\equiv \\alpha|0\\rangle+\\beta|1\\rangle$和$|\\psi,0\\rangle\\equiv|\\psi\\rangle|0\\rangle$。\n",
+ "\n",
+ "因此,用$|B_{00}\\rangle$投影后我们有\n",
+ "\n",
+ "$$\n",
+ "\\frac{1}{\\sqrt{2}}(\\langle B_{00}|\\psi,0\\rangle|0\\rangle+\\langle B_{00}|\\psi,1\\rangle|1\\rangle)=\\frac{1}{2}(\\alpha|0\\rangle+\\beta|1\\rangle)=\\frac{1}{2}|\\psi\\rangle\n",
+ "$$\n",
+ "\n",
+ "也可以尝试另外几种可能。\n",
+ "\n",
+ "## 不可克隆原理\n",
+ "\n",
+ "在经典世界中,经典信息可以被复制任意次数。\n",
+ "$$\n",
+ "0 \\rightarrow 00000000\\dots, 1 \\rightarrow 111111\\dots\n",
+ "$$\n",
+ "例如我们可以用CNOT实现经典克隆,对于$x\\in [0, 1]$,\n",
+ "$$\n",
+ "U_{CNOT}|x\\rangle|0\\rangle=|x\\rangle|x\\rangle\n",
+ "$$\n",
+ "关键是不可能对(**未知**)量子态进行这样的(**与状态无关的**)操作,即**完美**克隆$|\\psi\\rangle \\rightarrow |\\psi\\rangle|\\psi\\rangle|\\psi\\rangle|\\psi\\rangle|\\psi\\rangle\\dots$是被量子力学禁止的。\n",
+ "\n",
+ "例如,对于$|\\psi\\rangle\\equiv\\alpha|0\\rangle+\\beta|1\\rangle$,\n",
+ "$$\n",
+ "U_{CNOT}|\\psi\\rangle|0\\rangle=\\alpha|00\\rangle+\\beta|11\\rangle \\neq|\\psi\\rangle|\\psi\\rangle\n",
+ "$$\n",
+ "\n",
+ "**证明**\n",
+ "\n",
+ "以下适用于任何规模的量子系统。\n",
+ "\n",
+ "- 假设存在这样的克隆机,即\n",
+ "\n",
+ "$$\n",
+ "U_{clone}|\\psi\\rangle|0\\rangle=|\\psi\\rangle|\\psi\\rangle\n",
+ "$$\n",
+ "\n",
+ "- 它应该适用于任何状态,因此\n",
+ "\n",
+ "$$\n",
+ "U_{clone}|\\phi\\rangle|0\\rangle=|\\phi\\rangle|\\phi\\rangle\n",
+ "$$\n",
+ "\n",
+ "- 当然,我们需要假定这样的操作是幺正的,这意味着\n",
+ "\n",
+ "$$\n",
+ "\\langle\\psi|\\phi\\rangle=\\langle\\psi|\\langle 0|U^\\dagger_{clone}U_{clone}|\\phi\\rangle|0\\rangle=\\langle\\psi|\\phi\\rangle^2\n",
+ "$$\n",
+ "\n",
+ "这就产生了矛盾。\n",
+ "\n",
+ "**备选证明**(基于线性)\n",
+ "\n",
+ "- 考虑量子比特$|\\psi\\rangle=\\alpha|0\\rangle+\\beta|1\\rangle$\n",
+ "\n",
+ "- 假设存在这样的克隆机,即\n",
+ "\n",
+ "$$\n",
+ "U_{clone}|\\psi\\rangle|0\\rangle=|\\psi\\rangle|\\psi\\rangle\n",
+ "$$\n",
+ "\n",
+ "- 还假设它是一个线性运算,即\n",
+ "\n",
+ "$$\n",
+ "U_{clone}|\\psi\\rangle|0\\rangle = \\alpha U_{clone}|0\\rangle|0\\rangle+\\beta U_{clone}|1\\rangle|0\\rangle=\\alpha |0\\rangle|0\\rangle+\\beta|1\\rangle|1\\rangle\n",
+ "$$\n",
+ "\n",
+ "这再次导致矛盾。\n",
+ "\n",
+ "## 通用量子门\n",
+ "\n",
+ "经典计算中存在着通用门,比如与非门。现在我们想找到量子计算的通用量子门集,且希望这些通用量子门作用的比特数尽可能少,这可能有许多不同的选择。\n",
+ "\n",
+ "作为一个例子,我们会对这样的集合感兴趣:\n",
+ "\n",
+ "$$\n",
+ "G= \\{ U_{CNOT}, R_z(\\theta),R_y(\\phi)\\}\n",
+ "$$"
+ ]
+ }
+ ],
+ "metadata": {
+ "interpreter": {
+ "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+ },
+ "kernelspec": {
+ "display_name": "Python 3.9.9 64-bit",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.13"
+ },
+ "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/lecture3.ipynb b/lecture3.ipynb
index 813dd9ebc3f03f91417a6235cfeb6a83aad02cc0..15f582e8bad959206b33fdfa81dedf6b7ef2cf53 100644
--- a/lecture3.ipynb
+++ b/lecture3.ipynb
@@ -6,23 +6,23 @@
"source": [
"# Lecture 3\n",
"## 贝尔态\n",
- "- 两比特的最大纠缠态称为贝尔态(总共四种):\n",
+ "两比特的最大纠缠态称为贝尔态(总共四种):\n",
"$$\n",
"|\\psi_{Bell} \\rangle = \\frac{1}{\\sqrt{2}}(|00\\rangle + |11\\rangle)\n",
"$$\n",
"\n",
- "- 剩下三种贝尔态为\n",
+ "剩下三种贝尔态为\n",
"$$\n",
"\\frac{1}{\\sqrt{2}}(|00\\rangle - |11\\rangle),\\enspace\\frac{1}{\\sqrt{2}}(|01\\rangle + |10\\rangle),\\enspace \\frac{1}{\\sqrt{2}}(|01\\rangle - |10\\rangle)\n",
"$$\n",
"\n",
- "- 多比特量子态表示为:\n",
+ "多比特量子态表示为:\n",
"$$\n",
"|\\psi_n \\rangle = \\sum_{x\\in[0,1]^n}c_{x_1 x_2 \\cdots x_n}|x_1 x_2 \\cdots x_n\\rangle = \\sum_{x\\in [0,1]^n} c_x|x\\rangle \\ ,\n",
"$$\n",
"其中 $\\sum_x |c_x|^2=1$。\n",
"\n",
- "- 若想在MindQuantum中将模拟器的量子态设置为第一种贝尔态,则需要得知贝尔态的列向量:\n",
+ "若想在MindQuantum中将模拟器的量子态设置为第一种贝尔态,则需要得知贝尔态的列向量:\n",
"$$\n",
"\\frac{1}{\\sqrt{2}}(|00\\rangle + |11\\rangle) = \\frac{1}{\\sqrt{2}}\\begin{pmatrix}\n",
"1 \\\\ 0 \\\\ 0 \\\\ 1\n",
@@ -60,7 +60,7 @@
"metadata": {},
"source": [
"## 幺正变换\n",
- "- 先前提到量子态是一个(列)向量$|\\psi\\rangle$(ket),并且其振幅的平方就是概率。与之对应的则是(行)向量$\\langle \\psi|$(bra),\n",
+ "先前提到量子态是一个(列)向量$|\\psi\\rangle$(ket),并且其振幅的平方就是概率。与之对应的则是(行)向量$\\langle \\psi|$(bra),\n",
"\n",
"$$\n",
"|\\psi \\rangle = \\alpha |0\\rangle + \\beta |1 \\rangle \\to \\langle \\psi| \\equiv \\alpha^* \\langle 0 | + \\beta^* \\langle 1|\n",
@@ -74,7 +74,7 @@
"\n",
"这也被称为归一化条件。\n",
"\n",
- "- 因此若量子态是一个向量,则改变量子态的操作必须是一个矩阵(基于线性代数)。\n",
+ "所以,若量子态是一个向量,则改变量子态的操作必须是一个矩阵(基于线性代数)。\n",
"$$\n",
"|\\psi\\rangle \\to U|\\psi\\rangle\n",
"$$\n",
@@ -84,13 +84,11 @@
"$$\n",
"其中$A^\\dagger \\equiv (A^T)^*$。\n",
"\n",
- "- 为了保证概率守恒,我们需要\n",
+ "为了保证概率守恒,我们需要\n",
"$$\n",
"\\langle \\psi|\\psi\\rangle = \\langle \\psi|U^\\dagger U|\\psi\\rangle = 1\n",
"$$\n",
- "对于所有可能的$|\\psi\\rangle$都成立。\n",
- "\n",
- "- 这就意味着\n",
+ "对于所有可能的$|\\psi\\rangle$都成立。这就意味着\n",
"$$\n",
"U^\\dagger U = I \\Rightarrow U^\\dagger = U^{-1}\n",
"$$\n",
@@ -104,23 +102,22 @@
"- 换句话说,任何量子计算的量子动力学行为都必须是一种幺正变换(的子集)。\n",
"\n",
"### 作为幺正变换的量子计算?\n",
- "- 接下来,我们可以想象量子计算是由一类幺正变换来表示,例如\n",
+ "接下来,我们可以想象量子计算是由一类幺正变换来表示,例如\n",
"$$\n",
"U|\\psi_{in}\\rangle=|\\psi_{out}\\rangle\n",
"$$\n",
- "- 传统上,物理学家以这种方式解决问题:已知初态和哈密顿量,寻找末态。\n",
- "- 但对于量子计算,通常我们已知初态与末态,而目标是找到量子线路$U$(量子算法)。\n",
- "- 与经典计算相比较:\n",
+ "\n",
+ "传统上,物理学家以这种方式解决问题:已知初态和哈密顿量,寻找末态。但对于量子计算,通常我们已知初态与末态,而目标是找到量子线路$U$(量子算法)。\n",
+ "\n",
+ "与经典计算相比较:\n",
"$$\n",
"f(x_{in})=y_{out}\n",
"$$\n",
- "- 我们稍后会表明量子计算是更加普适的,这意味着我们也可以用量子计算机完成经典计算任务。\n",
- "- 问题的关键是一旦定义好输入与输出之间的逻辑关系,我们需要知道如何在物理上实现其对应的幺正变换(称为量子电路)。\n",
- "- 回想一下,经典电路由基本的逻辑运算组成。(AND, OR, NOT, NAND等)\n",
- "- 量子电路同样应该由基本逻辑运算组成,它们是什么?(我们会在之后发现)\n",
+ "我们稍后会表明量子计算是更加普适的,这意味着我们也可以用量子计算机完成经典计算任务。问题的关键是一旦定义好输入与输出之间的逻辑关系,我们需要知道如何在物理上实现其对应的幺正变换(称为量子电路)。回想一下,经典电路由基本的逻辑运算组成(AND, OR, NOT, NAND等),量子电路同样应该由基本逻辑运算组成,它们是什么?(我们会在之后发现)\n",
+ "\n",
"\n",
+ "**术语**\n",
"\n",
- "## 术语\n",
"- 量子线路:实现量子算法的一种方式(更大的幺正矩阵)\n",
"\n",
"- 量子门:量子电路的元素(较小的幺正矩阵)\n",
@@ -130,27 +127,27 @@
"## 泡利`X`门\n",
"**单量子比特门$\\equiv$单量子比特幺正矩阵(变换)**\n",
"\n",
- "- 让我们从经典的单比特门入手:\n",
+ "让我们从经典的单比特门入手:\n",
"$$\n",
"Logical \\enspace NOT \\enspace gate: \\enspace 1 \\to 0 \\enspace and \\enspace 0 \\to 1\n",
"$$\n",
- "- 而现在我们想要如下效果\n",
+ "而现在我们想要如下效果\n",
"$$\n",
"Logical \\enspace NOT \\enspace gate: \\enspace |1\\rangle \\to |0\\rangle \\enspace and \\enspace |0\\rangle \\to |1\\rangle\n",
"$$\n",
"这也被称为**比特翻转**。\n",
"\n",
- "- 使用泡利`X`门就可以做到上述操作\n",
+ "使用泡利`X`门就可以做到上述操作\n",
"$$\n",
"\\sigma_x \\equiv U_X \\equiv X = |1\\rangle\\langle 1| = \\begin{pmatrix} 0 & 1 \\\\ 1 & 0 \\end{pmatrix}\n",
"$$\n",
"\n",
- "- 可以验证泡利`X`门是幺正矩阵:\n",
+ "可以验证泡利`X`门是幺正矩阵:\n",
"$$\n",
"X^\\dagger X = \\begin{pmatrix} 0 & 1 \\\\ 1 & 0 \\end{pmatrix}\\begin{pmatrix} 0 & 1 \\\\ 1 & 0 \\end{pmatrix} = \\begin{pmatrix} 1 & 0 \\\\ 0 & 1 \\end{pmatrix} = I\n",
"$$\n",
"\n",
- "- 用狄拉克符号可以容易的验证:\n",
+ "用狄拉克符号可以容易的验证:\n",
"\n",
"$$\n",
"X|1\\rangle = (|1\\rangle\\langle 0|+|0\\rangle\\langle 1|)|1\\rangle = |1\\rangle\\langle 0|1\\rangle + |0\\rangle\\langle 1|1\\rangle = |0\\rangle\n",
@@ -160,7 +157,7 @@
"X|0\\rangle = (|1\\rangle\\langle 0|+|0\\rangle\\langle 1|)|0\\rangle = |1\\rangle\\langle 0|0\\rangle + |0\\rangle\\langle 1|0\\rangle = |1\\rangle\n",
"$$\n",
"\n",
- "- 泡利`X`门作用在任意量子态的效果如下:\n",
+ "泡利`X`门作用在任意量子态的效果如下:\n",
"$$\n",
"X|\\psi\\rangle=X(\\alpha|0\\rangle+\\beta|1\\rangle)=\\alpha X|0\\rangle+\\beta X|1\\rangle = \\alpha |1\\rangle+\\beta |0\\rangle\n",
"$$\n",
@@ -171,7 +168,7 @@
"\n",
"
\n",
"\n",
- "- 现在我们可以尝试在MindQuantum中搭建一个简单的量子电路——对一个量子比特作用泡利`X`门。首先创建一个量子电路:"
+ "现在我们可以尝试在MindQuantum中搭建一个简单的量子电路——对一个量子比特作用泡利`X`门。首先创建一个量子电路:"
]
},
{
@@ -252,7 +249,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.9.9"
+ "version": "3.8.13"
},
"orig_nbformat": 4
},
diff --git a/lecture5.ipynb b/lecture5.ipynb
index c7e4fdbad73f74e114b3579fde74a4ca8c50bd67..d89902f7c27ae82796cc4cb4ba3e55fe6dd04eb9 100644
--- a/lecture5.ipynb
+++ b/lecture5.ipynb
@@ -6,8 +6,9 @@
"source": [
"# Lecture 5\n",
"\n",
- "**Lecture 4 课后练习解答**\n",
- "- 考虑$R_x(\\theta)=e^{-i\\theta X/2}$,让我们回顾一下$e$指数上矩阵的定义——级数展开,现在我们考虑如下简单情形:\n",
+ "**计算$R_x(\\theta)$的矩阵**\n",
+ "\n",
+ "考虑$R_x(\\theta)=e^{-i\\theta X/2}$,让我们回顾一下$e$指数上矩阵的定义——级数展开,现在我们考虑如下简单情形:\n",
"$$\n",
"Q_\\theta = e^{\\theta X} = I+\\theta X + \\frac{\\theta^2}{2!}X^2+\\frac{\\theta^3}{3!}X^3+\\cdots\n",
"$$\n",
@@ -17,7 +18,7 @@
"$$\n",
"又有$e^x=\\cosh{x}+\\sinh{x}$,因此我们可以将上式总结为$Q_\\theta=I\\cosh{\\theta}+X\\sinh{\\theta}$。\n",
"\n",
- "- 将$\\theta$替换为$-i\\theta/2$,即得到\n",
+ "将$\\theta$替换为$-i\\theta/2$,即得到\n",
"\n",
"$$\n",
"R_{x}(\\theta)=I \\cos \\frac{\\theta}{2}-i X \\sin \\frac{\\theta}{2}=\\left(\\begin{array}{cc}\n",
@@ -32,7 +33,7 @@
"\\end{array}\\right) .\n",
"$$\n",
"\n",
- "- 同样的,由于$Y|0\\rangle=i|1\\rangle$,并且\n",
+ "同样的,由于$Y|0\\rangle=i|1\\rangle$,并且\n",
"$$\n",
"R_y(\\theta)=Icos\\frac{\\theta}{2}-iYsin\\frac{\\theta}{2}\n",
"$$\n",
@@ -40,7 +41,9 @@
"\n",
"---\n",
"\n",
- "**下面的特性你需要了解:**\n",
+ "## $R_z$门\n",
+ "\n",
+ "$R_z$门有以下几个特性:\n",
"$$\n",
"X R_{z}(\\theta) X=R_{z}(-\\theta)=R_{z}(\\theta)^{-1}=R_{z}(\\theta)^{\\dagger}\n",
"$$\n",
@@ -137,7 +140,7 @@
"output_type": "stream",
"text": [
"q0: ──RZ(1)^-1──\n",
- "(0.877582561890373+0.4794255386042032j)¦0⟩\n"
+ "(0.8775825618903726+0.47942553860420295j)¦0⟩\n"
]
}
],
@@ -184,44 +187,44 @@
"metadata": {},
"source": [
"\n",
- "- 最后,为何一定是$X, Y, Z$?我们也可以考虑一个任意的旋转。这需要我们定义\n",
+ "最后,为何一定是$X, Y, Z$?我们也可以考虑一个任意的旋转。这需要我们定义\n",
"$$\n",
"R_{n}(\\theta) \\equiv e^{-i(\\theta / 2) n \\cdot \\sigma}=c_{\\theta} I-i s_{\\theta}(n \\cdot \\sigma)\n",
"$$\n",
"其中$n\\cdot\\sigma\\equiv n_x X+n_y Y+n_z Z$,且$n_x^2+n_y^2+n_z^2=1$。(第二个等式是一个好的练习/作业)\n",
"\n",
- "- 该旋转算子可以生成任意的单量子比特旋转$U$(相差一个全局相位)。从某种意义上说,给定任何的$U$,人们总是可以选择角度$\\theta$和旋转轴$\\hat{n}$,使得(**想想看**)\n",
+ "该旋转算子可以生成任意的单量子比特旋转$U$(相差一个全局相位)。从某种意义上说,给定任何的$U$,人们总是可以选择角度$\\theta$和旋转轴$\\hat{n}$,使得(**想想看**)\n",
"$$\n",
"U=e^{i\\alpha}R_n(\\theta)\n",
"$$\n",
"\n",
- "---\n",
+ "**部分证明**\n",
"\n",
- "- 部分证明:首先,任何 $2\\times 2$ 矩阵都可以用泡利矩阵展开(完全基)。回想一下,任何状态都可以用 0,1 基分解,即$|\\psi\\rangle=a|0\\rangle+b|1\\rangle$。一开始你不需要知道 a 和 b。 为了确定它们,我们可以使用内积,$\\langle 0|\\psi\\rangle=a\\langle 0|0\\rangle + b\\langle 0|1\\rangle=a$。\n",
+ "首先,任何 $2\\times 2$ 矩阵都可以用泡利矩阵展开(完全基)。回想一下,任何状态都可以用 0,1 基分解,即$|\\psi\\rangle=a|0\\rangle+b|1\\rangle$。一开始,你不需要知道 a 和 b。 要确定它们,我们可以使用内积,$\\langle 0|\\psi\\rangle=a\\langle 0|0\\rangle + b\\langle 0|1\\rangle=a$。\n",
"\n",
- "- 类似的,我们可以对泡利矩阵做同样的事。即对任意$2\\times 2$矩阵$U$,我们总是可以写出\n",
+ "类似的,我们可以对泡利矩阵做同样的事。即对任意$2\\times 2$矩阵$U$,我们总是可以写出\n",
"$$\n",
"U=aI+bX+cY+dZ\n",
"$$\n",
"\n",
- "- 第一步,$X, Y, Z$泡利矩阵是无迹的。(迹 $\\operatorname{Tr}$ 含义是对矩阵对角线上的值求和;$\\operatorname{Tr}$ 是线性运算)\n",
+ "第一步,$X, Y, Z$泡利矩阵是无迹的。(迹 $\\operatorname{Tr}$ 含义是对矩阵对角线上的值求和;$\\operatorname{Tr}$ 是线性运算)\n",
"$$\n",
"\\operatorname{Tr}(U)=a \\operatorname{Tr}(I)+b \\operatorname{Tr}(X)+c \\operatorname{Tr}(Y)+d \\operatorname{Tr}(Z)=2 a\n",
"$$\n",
"这意味着$a=\\operatorname{Tr}(U)/2$。\n",
"\n",
- "- 接下来我们将$X$作用于$U$,得到\n",
+ "接下来我们将$X$作用于$U$,得到\n",
"$$\n",
"XU=aX+bI+cXY+dXZ\n",
"$$\n",
"\n",
- "- 然后对上式求迹,\n",
+ "然后对上式求迹,\n",
"$$\n",
"\\operatorname{Tr}(X U)=b \\operatorname{Tr}(I)+c \\operatorname{Tr}(X Y)+d \\operatorname{Tr}(X Z)=2 b\n",
"$$\n",
"这意味着 $b=\\operatorname{Tr}(XU)/2$ 。同理有 $c=\\operatorname{Tr}(YU)/2$ 和 $d=\\operatorname{Tr}(ZU)/2$ 。\n",
"\n",
- "- 至此,如果我们使$a=|a|e^{i\\alpha}$,离证明完成已经非常接近了。"
+ "至此,如果我们使$a=|a|e^{i\\alpha}$,离证明完成已经非常接近了。"
]
},
{
@@ -231,7 +234,9 @@
"\n",
"---\n",
"\n",
- "- 哈达玛门$H$ (Hadamard gate):(我认为几乎所有量子电路都有哈达玛门)\n",
+ "## 哈达玛门\n",
+ "\n",
+ "几乎所有量子电路都有哈达玛门 (Hadamard gate)。哈达玛门$H$:\n",
"$$\n",
"H \\equiv \\frac{1}{\\sqrt{2}}\\left(\\begin{array}{cc}\n",
"1 & 1 \\\\\n",
@@ -249,16 +254,16 @@
"H|0\\rangle=\\frac{1}{\\sqrt{2}}(|0\\rangle+|1\\rangle) \\quad, H|1\\rangle=\\frac{1}{\\sqrt{2}}(|0\\rangle-|1\\rangle)\n",
"$$\n",
"\n",
- "- 注意到$H$也是自逆的,即$H^2=I$,并且$H=(X+Z)/\\sqrt{2}$。\n",
+ "注意到$H$也是自逆的,即$H^2=I$,并且$H=(X+Z)/\\sqrt{2}$。\n",
"\n",
- "- 以下是一些哈达玛门的性质会在之后用到:\n",
+ "以下是一些哈达玛门的性质:\n",
"$$\n",
"HXH=Z\\quad HZH=X\\quad HYH=-Y\n",
"$$\n",
"\n",
- "- 例如,$HR_x(\\theta)H=Icos\\frac{\\theta}{2}-iHXHsin\\frac{\\theta}{2}=R_z(\\theta)$。\n",
+ "例如,$HR_x(\\theta)H=Icos\\frac{\\theta}{2}-iHXHsin\\frac{\\theta}{2}=R_z(\\theta)$。\n",
"\n",
- "- 最后我们还需要知道另外两个单比特门:\n",
+ "最后我们还需要知道另外两个单比特门:\n",
"$$\n",
"S \\equiv\\left(\\begin{array}{ll}\n",
"1 & 0 \\\\\n",
@@ -270,9 +275,7 @@
"$$\n",
"并且有$S=T^2$。\n",
"\n",
- "- 实际上,在实验室中,人们可能不具备从任意方向控制量子比特旋转的能力。\n",
- "\n",
- "- 比如说,如果我们只能实现$R_z$和$R_y$该怎么办?\n",
+ "实际上,在实验室中,人们可能不具备从任意方向控制量子比特旋转的能力。比如说,如果我们只能实现$R_z$和$R_y$该怎么办?\n",
"\n",
"
\n",
"\n",
@@ -349,7 +352,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.9.9"
+ "version": "3.8.13"
},
"orig_nbformat": 4
},
diff --git a/lecture7.ipynb b/lecture7.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..8d74452343e30fc7d2f7e7d97c92fef05bf34845
--- /dev/null
+++ b/lecture7.ipynb
@@ -0,0 +1,314 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Lecture 7\n",
+ "\n",
+ "## ABC分解\n",
+ "\n",
+ "对于一个任意的单比特幺正门,可以有以下分解:\n",
+ "$$\n",
+ "U=e^{i\\alpha}AXBXC\n",
+ "$$\n",
+ "其中$A$,$B$和$C$是旋转算符的乘积,$X$是泡利$X$算符,并且有$ABC=I$。这个分解对于构建两比特控制$U$门起到重要作用。问题的关键在于该如何找到$A, B, C$的显式形式,并且满足$ABC=I$。\n",
+ "\n",
+ "---\n",
+ "\n",
+ "**证明**\n",
+ "\n",
+ "考虑如下trick:\n",
+ "$$\n",
+ "R_{y}\\left(\\frac{\\gamma}{2}\\right) X^{c} R_{y}\\left(\\frac{-\\gamma}{2}\\right) X^{c}\n",
+ "$$\n",
+ "(i) $c=1$,我们有$R_y(\\frac{\\gamma}{2})XR_y(\\frac{-\\gamma}{2})X=R_y(\\gamma)$\n",
+ "\n",
+ "(ii) $c=0$,我们有$R_y(\\frac{\\gamma}{2})R_y(\\frac{-\\gamma}{2})=I$\n",
+ "\n",
+ "这就是一个基本的控制$R_y$门。现在如果我们考虑如下形式:\n",
+ "$$\n",
+ "R_{z}(\\beta) R_{y}\\left(\\frac{\\gamma}{2}\\right) \\cdot X^{c} R_{y}\\left(\\frac{-\\gamma}{2}\\right) X^{c}\n",
+ "$$\n",
+ "(i) 当$c=1$时上式回归到$R_z(\\beta)R_y(\\gamma)$,这还缺少一个因子$R_z(\\delta)$。\n",
+ "\n",
+ "(ii) 当$c=0$,我们有$R_z(\\beta)$。\n",
+ "\n",
+ "因此我们需要为这些情况构造$R_z$门。让我们考虑这额外的部分,\n",
+ "$$\n",
+ "X^xR_z(a)X^cR_z(b)\n",
+ "$$\n",
+ "(i) $c=1$,上式变为$R_z(-a+b)$;\n",
+ "\n",
+ "(ii) $c=0$,上式变为$R_z(a+b)$。\n",
+ "\n",
+ "因此我们只要令$\\delta=-a+b$和$-\\beta=a+b$,亦即$a=-(\\beta+\\delta)/2$和$b=(\\delta-\\beta)/2$。综合以上内容,如下形式应当能给出正确解答:\n",
+ "$$\n",
+ "R_{z}(\\beta) R_{y}\\left(\\frac{\\gamma}{2}\\right) \\cdot X^{c} R_{y}\\left(\\frac{-\\gamma}{2}\\right) X^{c} \\cdot X^{c} R_{z}(a) X^{c} R_{z}(b)=R_{z}(\\beta) R_{y}\\left(\\frac{\\gamma}{2}\\right) X^{c} R_{y}\\left(\\frac{-\\gamma}{2}\\right) R_{z}(a) X^{c} R_{z}(b)\n",
+ "$$\n",
+ "\n",
+ "即\n",
+ "$$\n",
+ "\\begin{aligned}\n",
+ "A & =R_{z}(\\beta) R_{y}\\left(\\frac{\\gamma}{2}\\right)\\\\\n",
+ "B & =R_{y}\\left(\\frac{-\\gamma}{2}\\right) R_{z}(a)\\\\\n",
+ "C & =R_z(b)\n",
+ "\\end{aligned}\n",
+ "$$\n",
+ "\n",
+ "关于单比特门的讨论到这里就结束了,接下来我们将关注双比特门,即$4\\times 4$的幺正矩阵。\n",
+ "\n",
+ "## CNOT门\n",
+ "\n",
+ "CNOT门应该是双比特门中最有名的一个,其作用在计算基矢的效果如下:\n",
+ "$$\n",
+ "|00\\rangle \\rightarrow |00\\rangle\n",
+ "$$\n",
+ "\n",
+ "$$\n",
+ "|01\\rangle \\rightarrow |01\\rangle\n",
+ "$$\n",
+ "\n",
+ "$$\n",
+ "|10\\rangle \\rightarrow |11\\rangle\n",
+ "$$\n",
+ "\n",
+ "$$\n",
+ "|11\\rangle \\rightarrow |10\\rangle\n",
+ "$$\n",
+ "\n",
+ "通常第一个比特被称为控制比特,第二个比特被称为目标比特。以上形式可以用更紧凑的形式表示:\n",
+ "$$\n",
+ "|x,y\\rangle \\rightarrow |x,y\\oplus x\\rangle\n",
+ "$$\n",
+ "\n",
+ "其中$y\\oplus x$是按位乘法(模二加法),等同于异或门(XOR gate)。\n",
+ "\n",
+ "以下是CNOT门的矩阵形式:\n",
+ "$$\n",
+ "U_{\\mathrm{CNOT}}=\\left[\\begin{array}{l}\n",
+ "1 \\\\\n",
+ "0 \\\\\n",
+ "0 \\\\\n",
+ "0\n",
+ "\\end{array}\\right]\\langle 00|+\\left[\\begin{array}{l}\n",
+ "0 \\\\\n",
+ "1 \\\\\n",
+ "0 \\\\\n",
+ "0\n",
+ "\\end{array}\\right]\\langle 01|+\\left[\\begin{array}{l}\n",
+ "0 \\\\\n",
+ "0 \\\\\n",
+ "0 \\\\\n",
+ "1\n",
+ "\\end{array}\\right]\\langle 10|+\\left[\\begin{array}{l}\n",
+ "0 \\\\\n",
+ "0 \\\\\n",
+ "1 \\\\\n",
+ "0\n",
+ "\\end{array}\\right]\\langle 11|=\\left[\\begin{array}{llll}\n",
+ "1 & 0 & 0 & 0 \\\\\n",
+ "0 & 1 & 0 & 0 \\\\\n",
+ "0 & 0 & 0 & 1 \\\\\n",
+ "0 & 0 & 1 & 0\n",
+ "\\end{array}\\right]\n",
+ "$$\n",
+ "\n",
+ "在量子线路中,CNOT门用下面的符号表示:\n",
+ "\n",
+ "\n",
+ "\n",
+ "实际上CNOT门就是控制X门:\n",
+ "\n",
+ "\n",
+ "\n",
+ "CNOT门是可逆的,并且有$CNOT \\enspace CNOT=I$。\n",
+ "\n",
+ "稍后我们将证明CNOT门与单比特门的集合对于量子计算是通用的,即我们可以用它们构造任意数量的量子比特的所有幺正变换。\n",
+ "\n",
+ "---\n",
+ "\n",
+ "在 MindQuanutum 中一般通过为X门添加控制位的方式得到CNOT门,因为 MindQuantum 可以简洁地为任意量子门添加控制位,只需要输入控制位作为第二个参数:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "q0: ──●──\n",
+ " │\n",
+ "q1: ──X──\n"
+ ]
+ }
+ ],
+ "source": [
+ "from mindquantum.core.gates import X\n",
+ "from mindquantum.core.circuit import Circuit\n",
+ "\n",
+ "circ = Circuit()\n",
+ "circ += X.on(1, 0)\n",
+ "print(circ)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "对于其它的量子门,同样可以用该方式添加控制位:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "q0: ──●──────●────\n",
+ " │ │\n",
+ "q1: ──Y──────┼────\n",
+ " │\n",
+ "q2: ───────RX(1)──\n"
+ ]
+ }
+ ],
+ "source": [
+ "from mindquantum.core.gates import Y, RX\n",
+ "from mindquantum.core.circuit import Circuit\n",
+ "\n",
+ "circ = Circuit()\n",
+ "circ += Y.on(1, 0)\n",
+ "circ += RX(1).on(2, 0)\n",
+ "print(circ)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## SWAP门\n",
+ "\n",
+ "三个CNOT门可以构成SWAP门:\n",
+ "\n",
+ "\n",
+ "\n",
+ "作用于 0,1 基的效果如下:\n",
+ "$$\n",
+ "\\begin{aligned}\n",
+ "|00\\rangle & \\rightarrow|00\\rangle \\rightarrow|00\\rangle \\rightarrow|00\\rangle \\\\\n",
+ "|01\\rangle & \\rightarrow|01\\rangle \\rightarrow|11\\rangle \\rightarrow|10\\rangle \\\\\n",
+ "|10\\rangle & \\rightarrow|11\\rangle \\rightarrow|01\\rangle \\rightarrow|01\\rangle \\\\\n",
+ "|11\\rangle & \\rightarrow|10\\rangle \\rightarrow|10\\rangle \\rightarrow|11\\rangle\n",
+ "\\end{aligned}\n",
+ "$$\n",
+ "\n",
+ "可以看到,SWAP门的作用正是交换两个比特的量子态,数学表示如下:\n",
+ "\n",
+ "$$\n",
+ "U_{S W A P}(\\alpha|0\\rangle+\\beta|1\\rangle)(\\gamma|0\\rangle+\\delta|1\\rangle)=(\\gamma|0\\rangle+\\delta|1\\rangle)(\\alpha|0\\rangle+\\beta|1\\rangle)\n",
+ "$$\n",
+ "\n",
+ "也可以记为以下形式:\n",
+ "\n",
+ "$$\n",
+ "U_{S W A P}(\\alpha \\gamma|00\\rangle+\\beta \\gamma|10\\rangle+\\alpha \\delta|01\\rangle+\\beta \\delta|11\\rangle)=\\alpha \\gamma|00\\rangle+\\beta \\gamma|01\\rangle+\\alpha \\delta|10\\rangle+\\beta \\delta|11\\rangle\n",
+ "$$\n",
+ "\n",
+ "---\n",
+ "\n",
+ "在MindQuantum中,SWAP门的用法与其它基本门相似,唯一的区别是它有两个目标比特,因此需要将包含两个目标位的`list[int]`作为参数输入:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "q0: ──@──\n",
+ " │\n",
+ "q1: ──@──\n"
+ ]
+ }
+ ],
+ "source": [
+ "from mindquantum.core.gates import SWAP\n",
+ "from mindquantum.core.circuit import Circuit\n",
+ "\n",
+ "circ = Circuit()\n",
+ "circ += SWAP.on([1, 0])\n",
+ "print(circ)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 作业\n",
+ "\n",
+ "1. 若$q_0$处于叠加态$| \\psi\\rangle =\\frac{1}{\\sqrt{2}}(|0\\rangle + |1\\rangle)$,$q_1$处于$|0\\rangle$态,现在对$q_0$、$q_1$作用CNOT门(控制位为$q_0$,目标位为$q_1$),请问该两比特系统的末态是什么样的,你是否能叫出它的名字?请用MindQuantum计算或验证你的结果。\n",
+ "\n",
+ "Hint:Lecture 5 中我们学过,哈达玛门`H`作用在$|0\\rangle$态效果如下:\n",
+ "$$\n",
+ "H|0\\rangle=\\frac{1}{\\sqrt{2}}(|0\\rangle+|1\\rangle)\n",
+ "$$"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "2. 请你用MindQuantum验证SWAP门可以分解为三个CNOT门(即两者矩阵等价)。"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "interpreter": {
+ "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+ },
+ "kernelspec": {
+ "display_name": "Python 3.9.9 64-bit",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.13"
+ },
+ "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/lecture9.ipynb b/lecture9.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..3c52c4399df81a304a0fd1ea577ae47410242170
--- /dev/null
+++ b/lecture9.ipynb
@@ -0,0 +1,215 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Lecture 9\n",
+ "\n",
+ "## CC-U 门分解\n",
+ "\n",
+ "接下来的讨论是为之后证明CNOT与单比特门的集合的通用性做铺垫,我们需要一些分解线路的方法作为工具。\n",
+ "\n",
+ "对于多控制门,我们考虑以下情况:\n",
+ "$$\n",
+ "U=V^2\n",
+ "$$\n",
+ "存在以下等价线路:\n",
+ "\n",
+ "\n",
+ "\n",
+ "这是一种用受控V门简化CC-U门的标准分解方法。\n",
+ "\n",
+ "为了理解它(不是证明它),让我们忘记第一个和最后一个控制操作。 在这种情况下,中间部分给出了以下变换:\n",
+ "\n",
+ "$$\n",
+ "\\begin{aligned}\n",
+ "|00\\rangle & \\rightarrow I \\qquad \\qquad |00\\rangle\\langle 00| \\otimes I \\rightarrow |00\\rangle\\langle 00| \\otimes I \\\\\n",
+ "|11\\rangle & \\rightarrow I \\qquad \\qquad |11\\rangle\\langle 11| \\otimes I \\rightarrow |11\\rangle\\langle 11| \\otimes V^2 \\\\\n",
+ "|01\\rangle & \\rightarrow V^\\dagger \\qquad \\quad |01\\rangle\\langle 01| \\otimes V^\\dagger \\rightarrow |01\\rangle\\langle 01| \\otimes V^\\dagger V \\\\\n",
+ "|10\\rangle & \\rightarrow V^\\dagger \\qquad \\quad |10\\rangle\\langle 10| \\otimes V^\\dagger \\rightarrow |10\\rangle\\langle 10| \\otimes V V^\\dagger\n",
+ "\\end{aligned}\n",
+ "$$\n",
+ "\n",
+ "CC-U门的效果实际上是这样:\n",
+ "$$\n",
+ "C_{U}=|00\\rangle\\langle 00|\\otimes I+| 01\\rangle\\langle 01|\\otimes I+| 10\\rangle\\langle 10|\\otimes I+| 11\\rangle\\langle 11| \\otimes U\n",
+ "$$\n",
+ "如果我们现在应用回第一个和最后一个受控操作,那么我们会得到正确的答案。\n",
+ "\n",
+ "
\n",
+ "\n",
+ "我们也可以选择一个实例,用 MindQuantum 验证以上线路的等价性,现在我们令$U = Y$。\n",
+ "\n",
+ "首先构建Toffoli门,可以通过`list`将多个控制位输入`Y`门的第二个参数得到多控制Y门。"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/svg+xml": "",
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from mindquantum.core.gates import Y\n",
+ "from mindquantum.core.circuit import Circuit\n",
+ "import mindquantum\n",
+ "circ = Circuit()\n",
+ "circ += Y.on(2, [0, 1])\n",
+ "circ.svg()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "接下来需要得到$V$使得$V^2 = Y$,这可以通过接口`Power()`实现。然后构建出相应线路。"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/svg+xml": "",
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from mindquantum.core.gates import Power, X\n",
+ "\n",
+ "V = Power(Y, 0.5)\n",
+ "circ2 = Circuit()\n",
+ "circ2 += V.on(2, 1)\n",
+ "circ2 += X.on(1, 0)\n",
+ "circ2 += V.hermitian().on(2, 1)\n",
+ "circ2 += X.on(1, 0)\n",
+ "circ2 += V.on(2, 0)\n",
+ "\n",
+ "circ2.svg()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "将两个线路的矩阵进行比对,判断是否等价。"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "True\n"
+ ]
+ }
+ ],
+ "source": [
+ "import numpy as np\n",
+ "\n",
+ "is_equiv = np.allclose(circ.matrix(), circ2.matrix())\n",
+ "print(is_equiv)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "可以看到,两个线路的对应矩阵完全相同。"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Toffoli 门\n",
+ "\n",
+ "当$U = X$时,得到的CC-X门被称为Toffoli门。在这种情况下,$V=(1-i)(I+iX)/2$。可以快速证明$V$是幺正的:\n",
+ "$$\n",
+ "V^\\dagger = (1+i)(I-iX)/2\n",
+ "$$\n",
+ "然后\n",
+ "$$\n",
+ "V^{\\dagger} V=\\frac{1}{4}(1-i)(1+i)(I-i X)(I+i X)=\\frac{1}{2}(I+I)=I\n",
+ "$$\n",
+ "现在我们知道如何用CNOT+单比特门集合来模拟Toffoli门。接下来是Toffoli门的第一个应用,分解多控制$U$门:\n",
+ "$$\n",
+ "C_{n}(U)\\left|x_{1} x_{2} x_{3} x_{4} x_{5}\\right\\rangle|\\psi\\rangle=\\left|x_{1} x_{2} x_{3} x_{4} x_{5}\\right\\rangle U^{x_{1} x_{2} x_{3} x_{4} x_{5}}|\\psi\\rangle\n",
+ "$$\n",
+ "下图中的$|c_1\\rangle,|c_2\\rangle\\cdots |c_5\\rangle$就等同于$\\left|x_{1} x_{2} x_{3} x_{4} x_{5}\\right\\rangle$:\n",
+ "\n",
+ "\n",
+ "\n",
+ "以上线路可以直接看出其效果:如果$c_1$和$c_2$都是$|1\\rangle$,则第一个辅助比特翻转为$|1\\rangle$;如果$c_3$和第一个辅助比特都是$|1\\rangle$则第二个辅助比特翻转为$|1\\rangle$(这意味着$c_1,c_2,c_3$都是$|1\\rangle$),依此类推。因此最后只有所有控制位都为$|1\\rangle$时才作用$U$门,即实现了多控制$U$门。\n",
+ "\n",
+ "**示例**\n",
+ "\n",
+ "考虑初态$\\alpha|00000\\rangle|\\psi\\rangle+\\beta|11111\\rangle|\\psi\\rangle$,插入中间的辅助量子比特后表示为$\\alpha|00000\\rangle|0000\\rangle|\\psi\\rangle+\\beta|11111\\rangle|0000\\rangle|\\psi\\rangle$。现在作用上述量子线路(到CU处截止),得到的量子态如下:\n",
+ "$$\n",
+ "\\alpha|00000\\rangle|0000\\rangle|\\psi\\rangle+\\beta|11111\\rangle|1111\\rangle U|\\psi\\rangle\n",
+ "$$\n",
+ "此时辅助比特与系统比特纠缠在一起,这不是我们想要的。因此我们需要在最后将它们全部重置为$|0\\rangle$态,这正是后半部分的那些顺序相反的Toffoli门的作用。\n",
+ "\n",
+ "## 作业\n",
+ "\n",
+ "设上图中的多控制U门为$U = R_x(\\frac{\\pi}{5})$,请用MindQuantum验证多控制$R_x$门可以分解为多个Toffoli门和控制$R_x$门(验证线路矩阵等价)。"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "interpreter": {
+ "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+ },
+ "kernelspec": {
+ "display_name": "Python 3.9.9 64-bit",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.13"
+ },
+ "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}