{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Paddle Quantum 入门手册\n",
    "\n",
    "<em> Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. </em>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a name=\"Overview\">总览</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这是一份简洁、实用的关于量子机器学习（Quantum Machine Learnig，QML）的介绍，面向读者包括但不限于物理、数学和计算机背景。本手册主要采用 Jupyter Notebook 的交互形式 (调用 Numpy, Matplotlib 等 Python 包以及飞桨 Paddlepaddle 深度学习框架来实现基于线性代数的量子运算和机器学习优化问题)。我们不仅提供了关于量子计算的一些基础教程，同时还能手把手带你完成属于你自己的第一份量子机器学习算法。这并不是一份关于量子计算的百科全书，但我们涉及的案例经常出现在教科书中以及文献中。如果你想深入挖掘一些相关的基础知识，我们也提供了一些外部链接方便用户自己学习。\n",
    "\n",
    "量子计算是由量子力学与计算理论交叉形成的新型学科，本质上是通过量子力学的基本规律去操控信息单元量子比特（quantum bit, qubit）的新型计算模式。与经典计算模型相比，在许多特定的信息处理任务上量子计算被普遍认为具有更强大的信息处理优势。关于量子计算的介绍与入门知识可以参考 [1-2]，想要系统性地学习量子计算学科的读者请参阅 Nielsen & Chuang 编写的经典教材 [3]。近期，量子计算领域中一个热门的课题是如何有效地结合量子计算和人工智能两者的潜能。量子机器学习便是这样一门结合了量子计算与机器学习的交叉学科，一方面研究者们希望利用量子计算的信息处理优势去促进人工智能的发展，另一方面也存在可能性去利用现有的人工智能的技术突破量子计算的研发瓶颈。关于量子机器学习的入门资料可以参考 [4-6]。\n",
    "\n",
    "内容上，这份快速入门包括以下几个方面：\n",
    "\n",
    "- 量子计算和量子神经网络的基础知识介绍\n",
    "- 量桨（Paddle Quantum）的使用介绍\n",
    "- 飞桨（PaddlePaddle）优化器的使用教程\n",
    "- 具体的量子机器学习案例—— 变分量子本征求解器（VQE）\n",
    "\n",
    "最后修改于: 2022年5月16日 由量桨 Paddle Quantum 开发小组共同完成。\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a name=\"Contents\">目录</a> \n",
    "\n",
    "<ul>\n",
    "    <li><a href=\"#Overview\">入门手册总览</a>\n",
    "    <li><a href=\"#Paddle\">安装</a>:\n",
    "         [<a href=\"#conda\">Conda 与环境配置</a>]\n",
    "        [<a href=\"#pq\">安装 Paddle Quantum包</a>]\n",
    "    <li><a href=\"#QC\">量子计算基础</a>:\n",
    "         [<a href=\"#qubit\">量子比特</a>]\n",
    "         [<a href=\"#gate\">量子门</a>]\n",
    "         [<a href=\"#measure\">测量</a>]\n",
    "         [<a href=\"#ex1\">示例和练习</a>]\n",
    "    <li><a href=\"#VA\">量子电路模板的搭建</a>: \n",
    "         [<a href=\"#QNN\">量子神经网络QNN</a>]\n",
    "         [<a href=\"#Ansatz\">内置电路模板</a>]\n",
    "    <li><a href=\"#VQA\">变分量子算法入门</a>: \n",
    "         [<a href=\"#VQAOverview\">概览</a>]\n",
    "         [<a href=\"#VQAQNN\">通过量子神经网络解优化问题</a>]\n",
    "         [<a href=\"#VQAStructure\">变分量子算法基本框架</a>]\n",
    "    <li><a href=\"#Mode\">量桨的运算模式</a>: \n",
    "         [<a href=\"#vec\">波函数向量模式</a>]\n",
    "         [<a href=\"#density\">密度矩阵模式</a>]\n",
    "         [<a href=\"#Bell\">练习：贝尔态</a>]\n",
    "    <li><a href=\"#Op\">飞桨优化器的使用</a>: \n",
    "         [<a href=\"#GD\">简单案例</a>]\n",
    "         [<a href=\"#ex2\">应用与练习</a>]\n",
    "    <li><a href=\"#References\">参考文献</a> \n",
    "        \n",
    "</ul>\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a name=\"Paddle\">安装教程</a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"conda\">Conda 与 Python 环境安装</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们推荐使用 [Anaconda](https://www.anaconda.com/download) 作为 Python3 的开发环境，支持多种主流操作系统（Windows, MacOS, 以及 Linux）。Anaconda 本身提供 Scipy, Numpy, Matplotlib 等科学计算、作图包，最主要的是其自带 Python 开发环境的管理器 conda，可以用来安装或者更新主流 Python 包。这里我们提供一个例子来学习使用 conda 创建和管理环境：\n",
    "\n",
    "1. 首先进入命令行 (Terminal) 界面：Windows 用户可以通过 `Anaconda Prompt`/ Mac用户可以使用组合键 `command⌘ + 空格` 再输入 `Terminal`。\n",
    "1. 进入 Terminal 后输入 `conda create --name paddle_quantum_env python=3.7` 创建名为 `paddle_quantum_env` 的 Python3.7 环境。\n",
    "1. 在 Terminal 内通过 `conda env list` 查看已有的环境，然后通过 `conda activate paddle_quantum_env ` 进入我们刚建立的环境。\n",
    "1. 为了能正确运行 Jupyter Notebook 我们还需要安装 `conda install jupyter notebook` 或者 `pip install jupyter notebook`。安装完成之后，如果你想开启 Jupyter 只需要在Terminal内激活正确的环境然后输入 `jupyter notebook` 即可。\n",
    "\n",
    "\n",
    "关于 conda 更多的本地指令请参考 [官方教程](https://docs.conda.io/projects/conda/en/latest/user-guide/getting-started.html)。\n",
    "<span class=\"blue\"> 此外，你也可以通过使用 <a href=\"https://docs.anaconda.com/anaconda/navigator/\"> Anaconda Navigator</a> 开启 jupyter notebook。\n",
    "\n",
    "以下是这个教程中你需要使用的包:\n",
    "<ul>\n",
    "    <li>Numpy\n",
    "    <li>Paddlepaddle 2.1.1+\n",
    "    <li>Paddle Quantum 2.0.0+\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"pq\">安装 Paddle 和 Paddle Quantum</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接着我们安装 Paddle Quantum 包，用户可以直接通过 `pip install paddle-quantum` 完成安装。关于本地安装方式，用户可以通过 Terminal 界面使用 git指令 `git clone http://github.com/PaddlePaddle/quantum` 或者直接下载 `zip` 压缩包，然后找到对应本地文件的路径输入 `cd quantum` 和 `pip install -e .` 完成安装。接着在 Terminal 界面输入`pip list`查看是否在正确的环境中安装完成。关于 git的使用和安装，请参考这篇 [教程](https://git-scm.com/book/zh/v2/%E8%B5%B7%E6%AD%A5-%E5%AE%89%E8%A3%85-Git)。此外，如果你需要更多的关于安装 Paddle Quantum 的帮助，可以参考我们的 [Github链接](https://github.com/PaddlePaddle/Quantum) 或者通过 Github Issues联系我们。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-30T09:18:51.118039Z",
     "start_time": "2021-04-30T09:18:47.681144Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import paddle\n",
    "import paddle_quantum\n",
    "from paddle import matmul, transpose, trace\n",
    "from paddle_quantum.ansatz import Circuit\n",
    "from paddle_quantum.state import State\n",
    "from paddle_quantum.linalg import dagger\n",
    "from paddle_quantum.qinfo import random_pauli_str_generator, pauli_str_to_matrix\n",
    "from paddle_quantum.visual import plot_state_in_bloch_sphere, plot_rotation_in_bloch_sphere\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上的几个代码块没有任何报错的话，恭喜你！接着就可以顺利运行全部的教程了！"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>[回到 <a href=\"#Contents\">目录</a>]</p>\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a name=\"QC\">量子计算基础</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "量子计算（Quantum Computing, QC）是利用量子物理中特有的现象（量子叠加态、量子相干性和量子纠缠等）来设计相应的量子算法以解决 （物理、化学、计算机等领域）特定的任务。现有的量子计算有存在几种模型，例如基于绝热定理的绝热量子计算模型（Adiabatic Quantum Computation, AQC）以及基于测量的量子计算模型（Measurement-Based Quantum Computation, MBQC）等等。在本介绍中，我们主要讨论目前影响力最大、使用最广泛的量子电路（Quantum Circuit）模型。在量子电路的框架下，运算最基本的组成单元是量子比特（qubit）。这与经典计算机中比特（bit）的概念很相似。经典比特只能处于0和1两种状态中的某一种（物理图景上可以对应晶体管的高低电位）。与之不同的是，量子比特不仅可以处于两个状态 $|0\\rangle$ 还有 $|1\\rangle$ 还可以处于两者的叠加态（稍后我们来具体讲解下这一概念）。在量子电路模型中，我们通过由一系列量子逻辑门构成的量子电路来操控这些量子比特的状态从而完成计算任务。逻辑门运算的基本理论是线性代数，在此我们假定读者已经具备一定的线性代数基础。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"qubit\">什么是量子比特？</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数学表示\n",
    "\n",
    "在量子力学中，一个二能级系统微观粒子（qubit）的量子态（quantum state）可以表示为由两个正规正交基线性组合得到的向量，这些基向量一般可以写为\n",
    "\n",
    "$$\n",
    "|0\\rangle := \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}, \\quad |1\\rangle := \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}.\n",
    "\\tag{1}\n",
    "$$\n",
    "\n",
    "这里向量的表示方法采用了量子物理上传统的狄拉克表示（bra-ket）。这两个单位正交向量 $\\{|0\\rangle, |1\\rangle \\}$ 一般被称为**计算基**（computational basis）。物理图景中我们可以认为 $|0\\rangle$ 和 $|1\\rangle$ 分别对应一个原子的能量基态和激发态或者其他一些二分类状态。 一个量子比特所有可能的态可以看作是二维希尔伯特空间中所有的归一化向量，这个希尔伯特空间的一组正规正交基正是 $\\{|0\\rangle, |1\\rangle \\}$。更多的量子比特系统也同样可以由高维度的希尔伯特空间中的的单位向量表示，而这个高维希尔伯特空间的正交基就是 $\\{|0\\rangle, |1\\rangle \\}$ 的张量积。比如说，一个两量子比特（2-qubit）系统可以被一个4维的希尔伯特空间里的单位复数向量表示，而这个希尔伯特空间的正规正交基是\n",
    "\n",
    "$$\n",
    "\\left\\{\n",
    "|00\\rangle = |0\\rangle\\otimes |0\\rangle := \\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0 \\end{bmatrix}, \\quad \n",
    "|01\\rangle = |0\\rangle\\otimes |1\\rangle := \\begin{bmatrix} 0 \\\\ 1 \\\\ 0 \\\\ 0 \\end{bmatrix}, \\quad\n",
    "|10\\rangle = |1\\rangle\\otimes |0\\rangle := \\begin{bmatrix} 0 \\\\ 0 \\\\ 1 \\\\ 0 \\end{bmatrix}, \\quad\n",
    "|11\\rangle = |1\\rangle\\otimes |1\\rangle := \\begin{bmatrix} 0 \\\\ 0 \\\\ 0 \\\\ 1 \\end{bmatrix}\n",
    "\\right\\}.\n",
    "\\tag{2}\n",
    "$$\n",
    "\n",
    "我们默认最左边的位置代表第一个量子比特，依此类推。其中符号 $\\otimes$ 是张量积运算。其工作原理大概如下：给定两个矩阵 $A_{m\\times n}$ 还有 $B_{p \\times q}$，那么 $A,B$ 的张量积为\n",
    "\n",
    "$$\n",
    "A \\otimes B = \n",
    "\\begin{bmatrix}\n",
    "a_{11}B & \\cdots & a_{1 n}B\\\\\n",
    "\\vdots  & \\ddots & \\vdots \\\\\n",
    "a_{m1}B & \\cdots & a_{m n}B\n",
    "\\end{bmatrix}_{(mp)\\times (nq)}\n",
    "\\tag{3}\n",
    "$$\n",
    "\n",
    "一个单量子比特所处的任意量子态 $|\\psi\\rangle$ 可以写成基向量 $|0\\rangle$ 和 $|1\\rangle$ 的线性叠加，也就是说，它可以被描述成一个 $|0\\rangle$ 和 $|1\\rangle$ 的线性组合：\n",
    "\n",
    "$$\n",
    "|\\psi\\rangle = \\alpha |0\\rangle  + \\beta |1\\rangle\n",
    ":= \\begin{bmatrix} \\alpha \\\\ \\beta \\end{bmatrix}.\n",
    "\\tag{4}\n",
    "$$\n",
    "\n",
    "其中 $\\alpha$ 和 $\\beta$ 可以是**复数**，他们表示概率振幅。这意味着当我们测量这个量子比特时，根据波恩法则，测量得到量子比特处于 $|0\\rangle$ 状态的概率是 $|\\alpha|^2$；而测量得到 $|1\\rangle$ 的概率是 $|\\beta|^2$。由于概率相加等于 1，我们必须要加入如下的限制条件：$|\\alpha|^2 + |\\beta|^2 = 1$。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  布洛赫球面表示\n",
    "\n",
    "布洛赫球面 (Bloch sphere) 是一个可以将单比特量子的状态 (纯态) 直观化的巧妙工具，其球面上的点表示单比特量子可能处于的量子态。（见图1）\n",
    "\n",
    "$$\n",
    "|\\psi\\rangle = \\alpha |0\\rangle  + \\beta |1\\rangle  \n",
    "= \\cos\\bigg(\\frac{\\theta}{2}\\bigg) |0\\rangle +  e^{i\\varphi}\\sin\\bigg(\\frac{\\theta}{2}\\bigg) |1\\rangle.\n",
    "\\tag{5}\n",
    "$$\n",
    "\n",
    "**对于经典比特，他的状态为 $|0\\rangle$ 或 $|1\\rangle$，对应着布洛赫球面的两极；对于量子比特，他的状态不仅可以为 $|0\\rangle$ 或 $|1\\rangle$，也可以是 $|0\\rangle$ 和 $|1\\rangle$ 的叠加态，所以球面上的任意一点都对应着一个量子态。** \n",
    "\n",
    "举例来说，量子态 $\\frac{1}{\\sqrt{2}}\\big(|0\\rangle + i|1\\rangle\\big)$就处于布洛赫球面赤道和 $y$-正半轴的交界处。\n",
    "\n",
    "<img src=\"figures/intro-fig-bloch.png\" width=\"400\" >\n",
    "\n",
    "&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;  \n",
    "&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;\n",
    "&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;\n",
    "&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;\n",
    "**图 1.** \n",
    "单比特量子态的布洛赫球面表示。[[图片来源]](https://en.wikipedia.org/wiki/Qubit)\n",
    "\n",
    "**注意**：多个比特量子的复合系统无法用布洛赫球面来表示。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 示例: 如何在布洛赫球面上展示自己创造的单比特量子态？\n",
    "\n",
    "我们以随机酉门的输出态为例，展示如何使用量桨内置函数绘制布洛赫球面。在这个例子中，我们使用随机的旋转角度来构造随机的酉算子，让初始化的量子线路通过这个酉算子，便可以得到量子线路的末态，这个末态就是一个随机的量子态。这样重复采样多次，生成一个量子态的列表，并采用量桨里 `visual` 包的函数将他们输入到布洛赫球面空间中，便可以实现对单比特量子态在布洛赫球面上的展示。\n",
    "\n",
    "具体代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 设置随机种子\n",
    "np.random.seed(42)\n",
    "# 采样的次数\n",
    "num_samples = 15\n",
    "# 存储采样得到的量子态\n",
    "states = []\n",
    "\n",
    "for i in range(num_samples):\n",
    "    \n",
    "    # 创建单比特量子的线路\n",
    "    cir = Circuit(1)\n",
    "\n",
    "    # 生成随机的旋转角度\n",
    "    phi, theta, omega = 2 * np.pi * np.random.uniform(size=3)\n",
    "    \n",
    "    # 对单比特量子态做随机的旋转操作\n",
    "    cir.rz(0, param=phi)\n",
    "    cir.ry(0, param=theta)\n",
    "    cir.rz(0, param=omega)\n",
    "    \n",
    "    # 运行电路\n",
    "    state = cir()\n",
    "    \n",
    "    # 将线路的末态存储起来\n",
    "    states.append(state.data)\n",
    "\n",
    "# 调用布洛赫球面展示功能，输入state参数，并且展示向量\n",
    "plot_state_in_bloch_sphere(states, show_arrow=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如上图所示，我们随机采样了 15 次，生成了 15 个随机的单比特量子态，将这 15 个量子态分别展示在布洛赫球面上，便可得到效果。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "量桨中对布洛赫球面的刻画有着丰富的功能，能够提供不同角度，不同视角距离的布洛赫球面展示。并且支持动态 gif 图的存储，方便学者们理解和学习。\n",
    "\n",
    "调用更加丰富的布洛赫球面功能请参考 `visual.plot_state_in_bloch_sphere()` 函数 API。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 示例: 如何在布洛赫球面上刻画单比特量子态旋转的\"轨迹\"？\n",
    "\n",
    "更进一步地，我们知道对单比特量子的酉算子操作，实际上可以认为是对布洛赫球面上的一个已知的布洛赫球向量做对某个轴的旋转操作。量子线路的初态对应布洛赫球面上最初的布洛赫球向量，量子线路的末态则对应布洛赫球面上旋转完成之后的布洛赫球向量。\n",
    "\n",
    "假设我们把一个从 $|0\\rangle$ 态经过了 $R_y(\\frac{\\pi}{4})$ 旋转门、$R_z(\\frac{\\pi}{2})$ 旋转门之后得到状态作为量子态的初始状态，把 $U3(\\theta = \\frac{\\pi}{2}, \\phi = \\frac{7\\pi}{8}, \\lambda = 2\\pi)$ 旋转门作为即将要做的酉算子操作，想用布洛赫球面来清晰地刻画这个酉算子操作的过程，需要如何做呢？\n",
    "\n",
    "在量桨中，我们可以把对单比特量子所做的酉算子操作，在布洛赫球面上通过生动形象的\"转动轨迹\"来展示。同样地，我们采用量桨里 `visual` 包的函数，通过输入量子态的初始状态 `init_state` 和 $U3$ 旋转门的角度，便可以实现这一效果。\n",
    "\n",
    "具体代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 创建单比特量子的线路\n",
    "cir = Circuit(1)\n",
    "\n",
    "# 设置量子态的初始状态\n",
    "cir.ry(0, param=np.pi/4)\n",
    "cir.rz(0, param=np.pi/2)\n",
    "init_state = cir()\n",
    "\n",
    "# 将要进行的酉算子操作\n",
    "theta = np.pi/2\n",
    "phi = 7*np.pi/8\n",
    "lam = 2*np.pi\n",
    "rotating_angle = [theta, phi, lam]\n",
    "\n",
    "# 调用布洛赫球面展示功能，输入初始状态init_state，酉算子的旋转角度rotating_angle\n",
    "plot_rotation_in_bloch_sphere(init_state, rotating_angle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如上图所示，偏右边的布洛赫球向量为初始量子态所对应的布洛赫球向量，偏左边的布洛赫球向量为做完酉算子之后的量子态所对应的布洛赫球向量。中间红色的点阵为量子态在做酉算子过程中所经过的\"轨迹\"。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "量桨中对布洛赫球面的\"轨迹\"刻画同样有着丰富的功能，能够提供不同角度，不同视角距离的布洛赫球面展示。并且支持动态 gif 图的存储，方便学者们理解和学习。\n",
    "\n",
    "调用更加丰富的布洛赫球面功能请参考 `visual.plot_rotation_in_bloch_sphere()` 函数 API。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"gate\">什么是量子逻辑门？</a>\n",
    "\n",
    "在经典计算机中，我们可以在经典比特上施加基本的逻辑运算（非门 NOT, 与非门 NAND, 异或门 XOR, 与门 AND, 或门 OR）并组合成更复杂的运算。而量子计算则有完全不同的一套逻辑运算，它们被称为量子门 (quantum gate)。我们并不能在一个量子计算机上编译现有的C++程序。因为**经典计算机和量子计算机有不同的逻辑门构造，所以量子算法是需要利用这些量子门的特殊性来构造的**。量子门在数学上可以被表示成酉矩阵（unitary matrix）。酉矩阵操作可以保证向量的长度不变，这是个很好的性质。不然我们对一个纯态量子比特进行操作，会让它劣化成混合态导致其无法接着很好地使用。酉矩阵定义为：\n",
    "\n",
    "$$\n",
    "U^{\\dagger}U = UU^{\\dagger} = I, \n",
    "\\quad \\text{并且} \\quad \n",
    "\\Vert |\\psi\\rangle \\Vert  = \\Vert U|\\psi\\rangle\\Vert = 1.\n",
    "\\tag{6}\n",
    "$$\n",
    "\n",
    "其中 $U^{\\dagger}$ 是 $U$ 的共轭转置，$I$ 表示单位矩阵。但是酉矩阵作为量子门的物理意义是什么？这意味着**所有的量子门都必须是可逆的**。对于任何一个量子门运算，都可以找到一个与其对应的反向运算。除此之外，酉矩阵必须是个方阵。因为量子门的输入和输出要求有同样数量的量子比特。一个作用在 $n$ 量子比特的量子门可以写成一个 $2^n \\times 2^n$ 的酉矩阵。最常见的（也是物理上最容易实现的）量子门作用在一个或两个量子比特上，就像经典逻辑门那样。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 单量子比特门\n",
    "\n",
    "接下来，我们介绍在量子计算中非常重要的单量子比特门，包括泡利矩阵 $\\{X, Y, Z\\}$、单比特旋转门 $\\{R_x, R_y, R_z\\}$ 和 Hadamard 门 $H$。其中 **非门（NOT gate）** 对于经典或量子计算都很重要，酉矩阵表示为：\n",
    "\n",
    "$$\n",
    "X := \\begin{bmatrix} 0 &1 \\\\ 1 &0 \\end{bmatrix}.\n",
    "\\tag{7}\n",
    "$$\n",
    "\n",
    "这个量子门（酉矩阵）作用在单量子比特（一个复向量）上本质上的运算是**矩阵乘以向量**：\n",
    "\n",
    "$$\n",
    "X |0\\rangle := \\begin{bmatrix} 0 &1 \\\\ 1 &0 \\end{bmatrix} \\begin{bmatrix} 1 \\\\0 \\end{bmatrix} \n",
    "=\\begin{bmatrix} 0 \\\\1 \\end{bmatrix} = |1\\rangle, \n",
    "\\quad \n",
    "X |1\\rangle := \\begin{bmatrix} 0 &1 \\\\ 1 &0 \\end{bmatrix} \\begin{bmatrix} 0 \\\\1 \\end{bmatrix} \n",
    "=\\begin{bmatrix} 1 \\\\0 \\end{bmatrix}=|0\\rangle.\n",
    "\\tag{8}\n",
    "$$\n",
    "\n",
    "回忆起前面的布洛赫球面表示，这个矩阵 $X$ 作用在一个量子比特（布洛赫球面上的一点）就相当于**关于布洛赫球的 $x$ 轴旋转角度 $\\pi$**。这就是为什么 $X$ 可以表示成 $R_x(\\pi)$（相差全局相位 $e^{-i\\pi/2} = -i$）。其他两个泡利矩阵 $Y$ 和 $Z$ 在这一点上也非常相似（代表绕 $y$ 和 $z$ 轴旋转 $\\pi$ 角度 ）：\n",
    "\n",
    "$$\n",
    "Y := \\begin{bmatrix} 0 &-i \\\\ i &0 \\end{bmatrix},\n",
    "\\quad \n",
    "Z := \\begin{bmatrix} 1 &0 \\\\ 0 &-1 \\end{bmatrix}.\n",
    "\\tag{9}\n",
    "$$\n",
    "\n",
    "一般来说，任何一个在布洛赫球关于相应的轴旋转 $\\theta$ 角度的量子门可以表示为：\n",
    "\n",
    "$$\n",
    "R_x(\\theta) := \n",
    "\\begin{bmatrix} \n",
    "\\cos \\frac{\\theta}{2} &-i\\sin \\frac{\\theta}{2} \\\\ \n",
    "-i\\sin \\frac{\\theta}{2} &\\cos \\frac{\\theta}{2} \n",
    "\\end{bmatrix}\n",
    ",\\quad \n",
    "R_y(\\theta) := \n",
    "\\begin{bmatrix}\n",
    "\\cos \\frac{\\theta}{2} &-\\sin \\frac{\\theta}{2} \\\\ \n",
    "\\sin \\frac{\\theta}{2} &\\cos \\frac{\\theta}{2} \n",
    "\\end{bmatrix}\n",
    ",\\quad \n",
    "R_z(\\theta) := \n",
    "\\begin{bmatrix}\n",
    "e^{-i\\frac{\\theta}{2}} & 0 \\\\ \n",
    "0 & e^{i\\frac{\\theta}{2}}\n",
    "\\end{bmatrix}.\n",
    "\\tag{10}\n",
    "$$\n",
    "\n",
    "除了旋转门之外，最重要的单比特门就是 Hadamard 门了。对应的布洛赫球面解释是两个旋转组成的，先是按 $z$ 轴旋转 $\\pi$，然后按 $y$ 轴旋转 $\\pi/2$。它的矩阵表示是\n",
    "\n",
    "$$\n",
    "H := \\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1 &1 \\\\ 1 &-1 \\end{bmatrix}.\n",
    "\\tag{11}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 两比特量子门\n",
    "\n",
    "从单量子比特门我们可以拓展到两量子比特门。有两种拓展方式，第一种是只挑选出一个量子比特，在上面施加单量子比特门，其他的量子比特则不进行任何操作。有的时候，会见到如下图所示的量子电路："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"figures/intro-fig-hadamard.png\" width=\"600\" >\n",
    "\n",
    "&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;  \n",
    "&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;\n",
    "&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;\n",
    "&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;\n",
    "**图 2.** \n",
    "两量子比特逻辑运算的电路表示和解读。[[图片来源]](https://en.wikipedia.org/wiki/Quantum_logic_gate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "作用在两量子比特上的量子门可以表示成一个 $4\\times4$ 酉矩阵：\n",
    "\n",
    "$$\n",
    "U = H \\otimes I \n",
    "= \\frac{1}{\\sqrt{2}} \\begin{bmatrix} 1 &1 \\\\ 1 &-1 \\end{bmatrix} \n",
    "\\otimes \\begin{bmatrix} 1 &0 \\\\ 0 &1 \\end{bmatrix} \n",
    "= \\frac{1}{\\sqrt{2}} \\,\n",
    "\\begin{bmatrix}\n",
    "1 &0 &1 &0  \\\\ \n",
    "0 &1 &0 &1  \\\\\n",
    "1 &0 &-1 &0 \\\\\n",
    "0 &1 &0 &-1 \n",
    "\\end{bmatrix}.\n",
    "\\tag{12}\n",
    "$$\n",
    "\n",
    "另一种拓展方式是将逻辑门直接作用在两个量子比特上。比如受控非门 $\\text{CNOT}$，这个门会使得一个量子比特的状态影响到另一个量子比特的状态\n",
    "\n",
    "$$\n",
    "\\text{CNOT} := \n",
    "\\begin{bmatrix} \n",
    "1 &0 &0 &0 \\\\ \n",
    "0 &1 &0 &0 \\\\\n",
    "0 &0 &0 &1 \\\\\n",
    "0 &0 &1 &0 \n",
    "\\end{bmatrix}.\n",
    "\\tag{13}\n",
    "$$\n",
    "\n",
    "我们观察一下它作用在不同的初始量子态上：\n",
    "\n",
    "$$\n",
    "\\text{CNOT} |00\\rangle = |00\\rangle, \\quad\n",
    "\\text{CNOT} |01\\rangle = |01\\rangle, \\quad\n",
    "\\text{CNOT} |10\\rangle = |11\\rangle, \\quad\n",
    "\\text{CNOT} |11\\rangle = |10\\rangle.\n",
    "\\tag{14}\n",
    "$$\n",
    "\n",
    "也就是说，当第一个量子比特处于 $|1\\rangle$ 状态时，$\\text{CNOT}$ 会在第二个量子比特上施加 $X$ 门，如果第一个量子比特处于 $|0\\rangle$ 状态，那么第二个量子比特则不受任何影响。这也是为什么 $\\text{CNOT}$ 会被称为受控非门。下面是一些常见的量子门及它们的矩阵表示，**这些量子门都可以在量桨内被调用**。\n",
    "\n",
    "![intro-fig-gates](./figures/intro-fig-gates.png \"**图 3.** 常见的量子门. [[图片来源]](https://en.wikipedia.org/wiki/Quantum_logic_gate)\")\n",
    "\n",
    "**注**：更多信息可见如下维基百科 [链接](https://en.wikipedia.org/wiki/Quantum_logic_gate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  <a name=\"measure\">什么是量子力学中的测量？</a>\n",
    "\n",
    "对于一个两分类的量子态，比如电子的自旋（Spin），我们规定该电子自旋向上 $\\uparrow$ 时记为 $|0\\rangle$ 态，自旋向下 $\\downarrow$ 时记为 $|1\\rangle$ 态。神奇的是，电子等微观粒子在被观测之前可以同时处于自旋向上和自旋向下的叠加态 $|\\psi\\rangle =\\alpha |0\\rangle  + \\beta |1\\rangle$。那么这个叠加态到底指的是什么呢？答案很简单，我们可以去测量一下这个处于\"叠加态\"的电子。值得注意的是，量子力学中的测量通常指的是一个统计结果而不是单次测量。这是由于测量本身的特性会使得观察后的量子态塌缩。就拿我们前面提到的处于 $|\\psi\\rangle$ 态的这个电子来举例，如果我们测量这一个电子的自旋，我们会有 $|\\alpha|^2$ 的概率观测到自旋向上并且观测后量子态塌缩成 $ |0\\rangle$。同样的，我们也有 $|\\beta|^2$ 的概率测量得到自旋向下$|1\\rangle$。那么想要精确的得到 $\\alpha$ 的数值，一次实验显然是不够的。我们需要拜托物理学家朋友准备了好多好多处于叠加态 $\\alpha |0\\rangle  + \\beta |1\\rangle$ 的电子，把每一个的自旋都测量再统计频率。测量在量子力学中地位比较特殊，如果读者觉得难理解。请参阅 [维基百科-量子力学中的测量](https://en.wikipedia.org/wiki/Measurement_in_quantum_mechanics#:~:text=In%20quantum%20physics%2C%20a%20measurement,makes%20are%20in%20general%20probabilistic.) 获取更多知识。\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##    <a name=\"ex1\">示例以及练习</a>\n",
    "\n",
    "### 示例: 用 Paddle Quantum 创建 $X$ 门\n",
    "\n",
    "**注意:** 所有的单比特旋转门都按如下规定建立：\n",
    "\n",
    "$$\n",
    "R_x(\\theta) := \n",
    "\\begin{bmatrix} \n",
    "\\cos \\frac{\\theta}{2} &-i\\sin \\frac{\\theta}{2} \\\\ \n",
    "-i\\sin \\frac{\\theta}{2} &\\cos \\frac{\\theta}{2} \n",
    "\\end{bmatrix}\n",
    ",\\quad \n",
    "R_y(\\theta) := \n",
    "\\begin{bmatrix}\n",
    "\\cos \\frac{\\theta}{2} &-\\sin \\frac{\\theta}{2} \\\\ \n",
    "\\sin \\frac{\\theta}{2} &\\cos \\frac{\\theta}{2} \n",
    "\\end{bmatrix}\n",
    ",\\quad \n",
    "R_z(\\theta) := \n",
    "\\begin{bmatrix}\n",
    "e^{-i\\frac{\\theta}{2}} & 0 \\\\ \n",
    "0 & e^{i\\frac{\\theta}{2}}\n",
    "\\end{bmatrix}.\n",
    "\\tag{15}\n",
    "$$\n",
    "\n",
    "因此，我们不难看出 $X$ 门可以表示为 $R_x(\\pi)$。以下是代码展示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-30T09:19:01.589007Z",
     "start_time": "2021-04-30T09:19:01.468170Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "量子门的矩阵表达式为：\n",
      "[[-4.371139e-08+0.j  0.000000e+00-1.j]\n",
      " [ 0.000000e+00-1.j -4.371139e-08+0.j]]\n"
     ]
    }
   ],
   "source": [
    "# 设置角度参数 theta = pi\n",
    "theta = np.pi\n",
    "\n",
    "# 设置计算所需的量子比特数量\n",
    "num_qubits = 1\n",
    "\n",
    "# 初始化单比特量子电路\n",
    "cir = Circuit(num_qubits)\n",
    "\n",
    "# 在第一个量子比特(第0号量子比特)的位置上施加一个 Rx 旋转门， 角度为 pi\n",
    "cir.rx(0, param=theta)\n",
    "\n",
    "# 打印出这个量子门\n",
    "# 转换成 numpy \n",
    "print('量子门的矩阵表达式为：')\n",
    "print(cir.unitary_matrix().numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "结果和 $X$（NOT）门只相差一个全局相位$-i$\n",
    "\n",
    "$$\n",
    "\\text{output} = \\begin{bmatrix} 0 &-i \\\\ -i &0 \\end{bmatrix}\n",
    "= -i\\begin{bmatrix} 0 &1 \\\\ 1 &0 \\end{bmatrix} = -i X.\n",
    "\\tag{16}\n",
    "$$\n",
    "\n",
    "有兴趣的话，你可以仔细思考一下为什么在量子计算中，全局相位并不重要。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 练习: 创建 $Y$ 门\n",
    "\n",
    "那么按照以上的例子依葫芦画瓢，你是否可以试着自己创建一个 $Y$ 门？试着补全下面的代码"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "theta = \"your code\"\n",
    "    \n",
    "num_qubits = 1\n",
    "cir = Circuit(\"your code\")\n",
    "cir.ry(\"your code\")\n",
    "print(cir.unitary_matrix().numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "和原来一样，我们还是多了一个全局相位\n",
    "\n",
    "$$\n",
    "\\text{output} = \\begin{bmatrix} 0 &-1 \\\\ 1 &0 \\end{bmatrix}\n",
    "= -i\\begin{bmatrix} 0 &-i \\\\ i &0 \\end{bmatrix} = -i Y.\n",
    "\\tag{17}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>[回到 <a href=\"#Contents\">目录</a>]</p>\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a name=\"VA\">量子电路模板/量子神经网络</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "经过上面的准备，你现在有一定的知识基础可以了解量子机器学习了。在量桨中我们提供了一系列基于量子神经网络实现机器学习的算法，简单来说，我们要做的就是利用参数化量子电路（Parametrized Quantum Circuit, PQC）来替代传统的神经网络来完成机器学习的任务。处理的对象可以是经典数据也可以是量子数据。\n",
    "\n",
    "在这一节我们介绍如何在量桨中创建可调节参数的量子电路（PQC），很多时候此类电路也被称作量子神经网络（Quantum Neural Network, QNN）或者电路模板（Ansatz），里面的参数是人为可调节的（这些参数大多数情况下就是旋转门的角度 $\\theta$）。例如上一节中看到的用参数 $\\pi$ 构造 $X$ 门，这其实就是最简单的量子神经网络。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"QNN\">示例: 如何创建量子神经网络 QNN？</a>\n",
    "\n",
    "QNN 通常可以表示为一些单比特量子旋转门和双比特门的组合。其中一个可以高效利用硬件的架构是只包含 $\\{R_x, R_y, R_z, \\text{CNOT}\\}$ 这四种量子门的模板。它们很容易在 NISQ （Noisy-Intermidiate-Scale-Quantum）设备（通常是超导量子比特）上实现，因为 $\\text{CNOT}$ 只需要实施在相邻量子比特上。一个例子可见下图：\n",
    "\n",
    "\n",
    "![intro-fig-gate1](./figures/intro-fig-gate1.png)\n",
    "\n",
    "通常来说，每条线代表一个量子比特。我们把图最上端的认为是第一个量子比特 $q_0$，依次往下。从左到右代表我们施加门的时间顺序，先施加最左边的量子门。接下来，我们来看看如何在量桨上建造这个简单的两比特量子神经网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-30T09:19:07.433031Z",
     "start_time": "2021-04-30T09:19:07.409641Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "图中量子神经网络 U(theta=pi) 的矩阵表达式是:\n",
      "[[-3.5527137e-15 -1.0000000e+00 -4.3711388e-08  4.3711395e-08]\n",
      " [-1.0000000e+00 -3.5527137e-15  4.3711381e-08 -4.3711388e-08]\n",
      " [ 4.3711388e-08 -4.3711395e-08  1.0000000e+00 -8.7422777e-08]\n",
      " [-4.3711381e-08  4.3711388e-08  8.7422777e-08  1.0000000e+00]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import paddle\n",
    "from paddle_quantum.ansatz import Circuit\n",
    "\n",
    "# 设置角度参数 theta \n",
    "theta = np.full([4], np.pi)\n",
    "\n",
    "# 初始化量子电路\n",
    "num_qubits = 2\n",
    "cir = Circuit(num_qubits)\n",
    "\n",
    "# 添加单比特旋转门\n",
    "cir.ry(0, param=theta[0])\n",
    "cir.ry(1, param=theta[1])\n",
    "\n",
    "# 添加两比特门\n",
    "cir.cnot([0, 1])\n",
    "\n",
    "# 添加单比特旋转门\n",
    "cir.ry(0, param=theta[2])\n",
    "cir.ry(1, param=theta[3])\n",
    "\n",
    "print('图中量子神经网络 U(theta=pi) 的矩阵表达式是:')\n",
    "print(cir.unitary_matrix().numpy().real)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\text{output} = \n",
    "\\begin{bmatrix} \n",
    "0  &-1 &0 &0 \\\\ \n",
    "-1 &0  &0 &0 \\\\\n",
    "0  &0  &1 &0 \\\\\n",
    "0  &0  &0 &1 \n",
    "\\end{bmatrix}.\n",
    "\\tag{18}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 练习\n",
    "\n",
    "给你如下代码，你能想象出对应的电路吗？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-30T09:19:17.518832Z",
     "start_time": "2021-04-30T09:19:17.507574Z"
    }
   },
   "outputs": [],
   "source": [
    "theta = np.full([6], np.pi)\n",
    "    \n",
    "num_qubits = 3\n",
    "cir = Circuit(num_qubits)  \n",
    "\n",
    "cir.ry(0, param=theta[0])\n",
    "cir.ry(1, param=theta[1])\n",
    "cir.ry(2, param=theta[2])\n",
    "\n",
    "cir.cnot([0, 1])\n",
    "cir.cnot([1, 2])\n",
    "\n",
    "cir.ry(0, param=theta[3])\n",
    "cir.ry(1, param=theta[4])\n",
    "cir.ry(2, param=theta[5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "答案如下:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"figures/intro-fig-gate2.png\" width=\"450\" >\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "也可以使用量桨中打印电路的功能查看构造好的电路："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Ry(3.142)----*----Ry(3.142)---------------\n",
      "               |                            \n",
      "--Ry(3.142)----x--------*--------Ry(3.142)--\n",
      "                        |                   \n",
      "--Ry(3.142)-------------x--------Ry(3.142)--\n",
      "                                            \n"
     ]
    }
   ],
   "source": [
    "print(cir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"Ansatz\">内置的电路模板</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在最新版本的 Paddle Quantum 中，我们提供了一些内置的电路模板方便场景部署。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:53:12.042782Z",
     "start_time": "2021-03-09T03:53:11.531307Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEPCAYAAABY9lNGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAbyklEQVR4nO3de5wdZZ3n8c83CQTkJmBEJdEwEnWCCKMR2fEyCoLwGgUcgwZQwUHjrDLKS2ecMDoI6O6IN9QlOMZFRFwJiLesRNAFGXdQMAlyMUCkhQSCMjZ3kAUMfPePqoaT09Wnqzt9Th063/frdV459TxV53zTf/Sv63mqnpJtIiIi2k1pOkBERPSnFIiIiKiUAhEREZVSICIiolIKREREVJrWdICJ8oxnPMOzZ89uOkZExFPKqlWr7rQ9o6pv0hSI2bNns3LlyqZjREQ8pUhaN1JfhpgiIqJSCkRERFRKgYiIiEopEBERUSkFIiIiKqVAREREpRSIiIiolAIRERGVUiAiIqLSpLmTelPNXnRhY9+99lN/3bE/2aol2/gk2/g8lbONV84gIiKiUgpERERUSoGIiIhKKRAREVGpqwVC0kGS1kgakLSoov81kq6StEHS/Jb2vSX9QtJqSddKels3c0ZExHBdKxCSpgKLgYOBucARkua27XYrcAzwrbb2h4B32t4DOAj4gqSndytrREQM183LXPcBBmzfDCBpKXAocP3QDrbXln2Ptx5o+zct738n6Q/ADODeLuaNiIgW3Rxi2hW4rWV7fdk2JpL2AbYEflvRt1DSSkkrBwcHxx00IiKG6+tJaknPBs4B3mX78fZ+20tsz7M9b8aMykeqRkTEOHWzQNwOzGrZnlm21SJpe+BC4KO2r5jgbBERMYpuFogVwBxJu0naElgALKtzYLn/94Bv2L6gixkjImIEXSsQtjcAxwEXAzcA59teLekUSYcASHq5pPXA4cBXJK0uD38r8BrgGElXl6+9u5U1IiKG6+pifbaXA8vb2k5seb+CYuip/bhvAt/sZraIiOisryepIyKiOSkQERFRKQUiIiIqpUBERESlFIiIiKiUAhEREZVSICIiolIKREREVEqBiIiISikQERFRKQUiIiIqpUBERESlFIiIiKiUAhEREZVSICIiolIKREREVEqBiIiISikQERFRKQUiIiIqpUBERESlFIiIiKiUAhEREZVSICIiolIKREREVOpqgZB0kKQ1kgYkLarof42kqyRtkDS/re9oSTeVr6O7mTMiIobrWoGQNBVYDBwMzAWOkDS3bbdbgWOAb7UduxPwceAVwD7AxyXt2K2sERExXDfPIPYBBmzfbPtRYClwaOsOttfavhZ4vO3YNwA/sX237XuAnwAHdTFrRES06WaB2BW4rWV7fdk2YcdKWihppaSVg4OD4w4aERHDPaUnqW0vsT3P9rwZM2Y0HSciYlIZtUBIeqWkbcr3b5f0eUnPq/HZtwOzWrZnlm11bMqxERExAeqcQXwZeEjSXsCHgd8C36hx3ApgjqTdJG0JLACW1cx1MXCgpB3LyekDy7aIiOiROgVig21TTDCfbnsxsN1oB9neABxH8Yv9BuB826slnSLpEABJL5e0Hjgc+Iqk1eWxdwOfoCgyK4BTyraIiOiRaTX2eUDSCcA7gFdLmgJsUefDbS8Hlre1ndjyfgXF8FHVsV8DvlbneyIiYuLVOYN4G/AI8Le276D4hf6ZrqaKiIjGjVogyqLwHWB62XQn8L1uhoqIiObVuYrpPcAFwFfKpl2B73cxU0RE9IE6Q0zvB14J3A9g+ybgmd0MFRERzatTIB4pl8oAQNI0wN2LFBER/aBOgfh3Sf8MbC3pAODbwP/ubqyIiGhanQKxCBgErgPeS3HZ6se6GSoiIpo36n0Qth8Hvlq+IiJiMzFigZB0vu23SrqOijkH2y/parKIiGhUpzOID5b/vrEXQSIior+MOAdh+/fl2/fZXtf6At7Xm3gREdGUOpPUB1S0HTzRQSIior90moP4rxRnCn8m6dqWru2Ay7sdLCIimtVpDuJbwI+Af6W41HXIA1l6OyJi8utUIGx7raT3t3dI2ilFIiJichvtDOKNwCqKy1zV0mfgz7qYKyIiGjZigbD9xvLf3XoXJyIi+kWnSeqXdjrQ9lUTHyciIvpFpyGmz3XoM7DfBGeJiIg+0mmI6XW9DBIREf2l0xDTfrYvlfQ3Vf22v9u9WBER0bROQ0x/BVwKvKmiz0AKRETEJNZpiOnj5b/v6l2ciIjoF6OuxSRpZ0lfknSVpFWSvihp516Ei4iI5tRZrG8pxRPl3gLML9+fV+fDJR0kaY2kAUmLKvqnSzqv7L9S0uyyfQtJZ0u6TtINkk6o/T+KiIgJUadAPNv2J2zfUr4+Cewy2kGSpgKLKVZ+nQscIWlu227HAvfY3h04DTi1bD8cmG57T+BlwHuHikdERPRGnQLxY0kLJE0pX28FLq5x3D7AgO2bbT9KcSZyaNs+hwJnl+8vAPaXJIpJ8G0kTQO2Bh4F7q/xnRERMUFGLBCSHpB0P/AeinWZHi1fS4GFNT57V+C2lu31ZVvlPrY3APcBO1MUiz8CvwduBT5btTigpIWSVkpaOTg4WCNSRETU1emJctvZ3r78d4rtaeVriu3tu5xrH+Ax4DnAbsCHJQ1bHND2EtvzbM+bMWNGlyNFRGxeOt0H8QRJOwJzgK2G2mz/bJTDbgdmtWzPLNuq9llfDiftANwFHAlcZPtPwB8kXQ7MA26ukzciIjZdnctc3w38jGLe4eTy35NqfPYKYI6k3SRtCSwAlrXtsww4unw/H7jUtimGlfYrv38bYF/gxhrfGRERE6TOJPUHgZcD68r1mf4CuHe0g8o5heMoCsoNwPm2V0s6RdIh5W5nAjtLGgA+xJNPrlsMbCtpNUWhOcv2tURERM/UGWJ62PbDkpA03faNkl5Y58NtLweWt7Wd2PL+YYpLWtuPe7CqPSIieqdOgVgv6enA94GfSLoHWNfNUBER0bxRC4TtN5dvT5L0U4qJ5Iu6mioiIhpX9yqmlwKvoriB7fLyxreIiJjE6lzFdCLF3c47A88AzpL0sW4Hi4iIZtU5gzgK2KucUEbSp4CrgU92MVdERDSszmWuv6PlBjlgOsNveIuIiEmm0yNH/wfFnMN9wGpJPym3DwB+2Zt4ERHRlE5DTCvLf1cB32tpv6xraSIiom90euTo0DLclEtlvKDcXFOukRQREZPYqJPUkl5LcRXTWkDALElH11isLyIinsLqXMX0OeBA22sAJL0AOJfiSW8RETFJ1bmKaYuh4gBg+zfAFt2LFBER/aDOGcQqSf8T+Ga5fRRPTmBHRMQkVadA/B3wfuAD5fb/Bc7oWqKIiOgLHQuEpKnANbZfBHy+N5EiIqIfdJyDsP0YsEbSc3uUJyIi+kSdIaYdKe6k/iXwx6FG24eMfEhERDzV1SkQ/9L1FBER0Xc6rcW0FcUE9e7AdcCZ5XOmIyJiM9BpDuJsYB5FcTiY4oa5iIjYTHQaYppre08ASWeSFVwjIjYrnc4gnliQL0NLERGbn05nEHtJur98L2DrcluAbW/f9XQREdGYTst9T+1lkIiI6C91FusbN0kHSVojaUDSoor+6ZLOK/uvlDS7pe8lkn4habWk68qrqiIioke6ViDKZToWU1wBNRc4QtLctt2OBe6xvTtwGnBqeew0isUB/872HsBraZkTiYiI7uvmGcQ+wIDtm20/CiwFDm3b51CKy2kBLgD2lyTgQOBa29cA2L6rXPYjIiJ6pJsFYlfgtpbt9WVb5T7llVL3ATtTPN7Uki6WdJWkj1R9gaSFklZKWjk4ODjh/4GIiM1ZpzupHwA8Un+Xr2KaBrwKeDnwEHCJpFW2L2nLsARYAjBv3rwRs0ZExNh1uoppOwBJnwB+D5xDcYnrUcCza3z27cCslu2ZZVvVPuvLeYcdgLsozjZ+ZvvOMsNy4KXAJURERE/UGWI6xPYZth+wfb/tLzN8LqHKCmCOpN0kbQksAJa17bMMOLp8Px+41LaBi4E9JT2tLBx/BVxf5z8UERETo06B+KOkoyRNlTRF0lG0LPs9knJO4TiKX/Y3AOfbXi3pFElDS4WfCewsaQD4ELCoPPYeigcUrQCuBq6yfeEY/28REbEJ6iz3fSTwxfJl4PKybVS2lwPL29pObHn/MHD4CMd+kyefgx0RET02aoGwvZZ6Q0oRETGJjDrEJOkFki6R9Oty+yWSPtb9aBER0aQ6cxBfBU6gvJPZ9rUUE84RETGJ1SkQT7Pd/iyILP8dETHJ1SkQd0p6PuVNc5LmU9wXERERk1idq5jeT3G38osk3Q7cQnGzXERETGIdC0S5Iuv7bL9e0jbAFNsP9CZaREQ0qWOBsP2YpFeV70e9OS4iIiaPOkNMv5K0DPg2LXdQ2/5u11JFRETj6hSIrSgW0Nuvpc1ACkRExCRW507qd/UiSERE9JdRC4Sks6h4LoTtv+1KooiI6At1hph+2PJ+K+DNwO+6EyciIvpFnSGm77RuSzoX+I+uJYqIiL4wnmdSzwGeOdFBIiKiv9SZg2h/NvUdwD91LVFERPSFOkNM2/UiSERE9Jc6z4N4ZbnMBpLeLunzkp7X/WgREdGkOnMQXwYekrQX8GHgt8A3upoqIiIaV6dAbLBtiseOnm57MZBhp4iISa7OfRAPSDoBeDvwGklTgC26GysiIppW5wzibcAjwLG27wBmAp/paqqIiGhcnauY7gA+37J9K5mDiIiY9OpcxbSvpBWSHpT0qKTHJN3Xi3AREdGcOkNMpwNHADcBWwPvBs6o8+GSDpK0RtKApEUV/dMlnVf2Xylpdlv/c8vC9A91vi8iIiZOraU2bA8AU20/Zvss4KDRjikfV7oYOBiYCxwhaW7bbscC99jeHTgNOLWt//PAj+pkjIiIiVXnKqaHJG0JXC3p08DvqVdY9gEGbN8MIGkpxaWy17fscyhwUvn+AuB0SbJtSYcBt9DyFLuIiOidOr/o31HudxzFL+tZwFtqHLcrcFvL9vqyrXIf2xuA+4CdJW1Lsd7TyZ2+QNJCSSslrRwcHKwRKSIi6qpzFdM6SVsDz7bd8Rf2BDoJOM32g5I6ZVsCLAGYN2/esIcaRUTE+NW5iulNwNXAReX23pKW1fjs2ynONobMLNsq95E0DdiB4vnXrwA+LWktcDzwz5KOq/GdERExQerMQZxEMZ9wGYDtqyXtVuO4FcCcct/bgQXAkW37LAOOBn4BzAcuLZf1ePXQDpJOAh60fXqN74yIiAlSp0D8yfZ9bUM9ow7n2N5Q/tV/MTAV+Jrt1ZJOAVbaXgacCZwjaQC4m6KIREREH6hTIFZLOhKYKmkO8AHg53U+3PZyYHlb24kt7x8GDh/lM06q810RETGx6lzF9PfAHhTrMZ0L3E8xLxAREZNYnauYHgI+Wr4iImIzMWKBGO1KJduHTHyciIjoF53OIP4LxU1s5wJXAiPfkBAREZNOpwLxLOAAioX6jgQuBM61vboXwSIiolkjTlKXC/NdZPtoYF9gALgsN6xFRGweOk5SS5oO/DXFWcRs4EvA97ofKyIimtZpkvobwIsp7mM42fave5YqIiIa1+kM4u0Uq7d+EPhAy53UAmx7+y5ni4iIBo1YIGzXephQRERMTikCERFRKQUiIiIqpUBERESlFIiIiKiUAhEREZVSICIiolIKREREVEqBiIiISikQERFRKQUiIiIqpUBERESlFIiIiKiUAhEREZVSICIiolIKREREVOpqgZB0kKQ1kgYkLarony7pvLL/Skmzy/YDJK2SdF35737dzBkREcN1rUBImgosBg4G5gJHSJrbttuxwD22dwdOA04t2+8E3mR7T+Bo4Jxu5YyIiGrdPIPYBxiwfbPtR4GlwKFt+xwKnF2+vwDYX5Js/8r278r21cDWkqZ3MWtERLTpZoHYFbitZXt92Va5j+0NwH3Azm37vAW4yvYj7V8gaaGklZJWDg4OTljwiIjo80lqSXtQDDu9t6rf9hLb82zPmzFjRm/DRURMct0sELcDs1q2Z5ZtlftImgbsANxVbs8Evge80/Zvu5gzIiIqdLNArADmSNpN0pbAAmBZ2z7LKCahAeYDl9q2pKcDFwKLbF/exYwRETGCrhWIck7hOOBi4AbgfNurJZ0i6ZBytzOBnSUNAB8Chi6FPQ7YHThR0tXl65ndyhoREcNN6+aH214OLG9rO7Hl/cPA4RXHfRL4ZDezRUREZ309SR0REc1JgYiIiEopEBERUSkFIiIiKqVAREREpRSIiIiolAIRERGVUiAiIqJSCkRERFRKgYiIiEopEBERUSkFIiIiKqVAREREpRSIiIiolAIRERGVUiAiIqJSCkRERFRKgYiIiEopEBERUSkFIiIiKqVAREREpRSIiIiolAIRERGVUiAiIqJSVwuEpIMkrZE0IGlRRf90SeeV/VdKmt3Sd0LZvkbSG7qZMyIihutagZA0FVgMHAzMBY6QNLdtt2OBe2zvDpwGnFoeOxdYAOwBHAScUX5eRET0SDfPIPYBBmzfbPtRYClwaNs+hwJnl+8vAPaXpLJ9qe1HbN8CDJSfFxERPTKti5+9K3Bby/Z64BUj7WN7g6T7gJ3L9ivajt21/QskLQQWlpsPSlozMdHH7BnAneM9WKdOYJLhkm18km18km18msz2vJE6ulkgus72EmBJ0zkkrbQ9r+kcVZJtfJJtfJJtfPo1WzeHmG4HZrVszyzbKveRNA3YAbir5rEREdFF3SwQK4A5knaTtCXFpPOytn2WAUeX7+cDl9p22b6gvMppN2AO8MsuZo2IiDZdG2Iq5xSOAy4GpgJfs71a0inAStvLgDOBcyQNAHdTFBHK/c4Hrgc2AO+3/Vi3sk6Axoe5Oki28Um28Um28enLbCr+YI+IiNhY7qSOiIhKKRAREVEpBSIiIiqlQGwCSTtJ2qnpHBER3ZACMUaSnitpqaRB4Ergl5L+ULbNbjhe35O0i6SXlq9dms4zGknbNp0hoim5immMJP0C+AJwwdClt+VCgocDx9vet8F4I5J0ne09G/z+vYF/o7gZcuimx5nAvcD7bF/VTLLOJN1q+7l9kGMXnlxu5nbb/9lknjokbWv7wYYziGIdtyd+dsAv3ce/+CS9yPaNTeeAFIgxk3ST7Tlj7esFSX8zUhfwb7Zn9DLPRgGkq4H32r6yrX1f4Cu292okWJHhQyN1AR+13dgw4lO1sELzxVXSgcAZwE1s/LPbneJn9+OmsnXS9M+t1VN6LaaGrJJ0BsUqtEOLEc6iuCP8V42lKpwH/C+gqupv1eMs7bZpLw4Atq+QtE0TgVr8d+AzFDdltmt6GPbrjFxYzwIaK6xljk7FtenhuS8Cr7e9trWxXJ1hOfDnTYQqM3xppC7g6T2M0lEKxNi9k+I5Fiez8Wnr0J3hTboW+KztX7d3SHp9A3la/UjShcA32LiwvhO4qLFUhauA79te1d4h6d0N5GnVz4UV+ru4TqNYCbrd7cAWPc7S7l3Ah4FHKvqO6HGWEWWIaRKR9Gpgne1bK/rm2V7ZQKzWDAdTPOtjo8Jqe3lzqUDSC4G7bA9bblnSLk2O95d/aT6f6sJ6i+3jmsoGIOnnwN+PUFxvsz2r4rCekHQC8FaKZ9G0/uwWAOfb/tcGs10KfMz2zyv6brG9WwOxhkmBGKNy1dljgcPY+BfdD4Azbf+poWgxSfVrYYUniuvdtgcr+hotrmWGP6f6Z3d9c6mKS+SBh20/1GSO0aRAjJGkcykmCM/mydPXmRRzEDvZfltD0VqL15uB55TNfV+8JC2xvXD0PXuvn7NFdFsKxBhJ+o3tF4y1rxf6vHiNdCWQgGtsz+xlno0C9He2HYATKP4K3oXiAoQ/UBT9T9m+t6lssFG+w4Bn0mf5RiLpR7YPbjpHlX7Klknqsbtb0uHAd2w/DiBpCsV9EPc0mgxeVlGg1gNXSPpNE4FaDALrKH7pDnG5/cxGEj2pn7OdD1wKvM72HQCSngUcU/Yd2Fw04Ml8r23LdzQN55P00pG6gL17GGV4gD7O1ipnEGNU3i19KvA6ir/Wobgs7afAItu3NBIMkHQF8Dmqi9eHbLc/E7yX2W4C9h9hAr3pycx+zrbG9gvH2tcr/ZxP0mPAv7Nx4R+yr+2texzpCf2crVXOIMbI9lpJJ1Hc87DRJHWTxaG0gKJ4LZZ0b9n2dIritaChTEO+AOwIDPslDHy6t1GG+QL9m22dpI8AZw9N+JZ3VR/Dk1fmNKmf891AcQ/JTe0dkpKthpxBjJGkf6L4ZbuUje/OXAAstf2pprLBiFdt/MD2Dc2lKkh6EdVXlCTbCCTtCCyiyDY03PWfFPfdfMp2o8Oa/ZxP0nzgOttrKvoOs/393qd64vv7NlurFIgxKsfy92i/Iqh87vbqhpfa6NviVf6VeWSZrXUCPdnGSdK7bJ/VdI6R9HO+ZKsnBWKMJN0IvMH2urb25wE/bnjMtZ+LV7JNsH5as6dKP+dLtnoyBzF2xwOXlBObQ2OFz6VYAKzRu1qBxynuf1jX1v7ssq9JyTYOkq4dqYvistdG9XO+ZNt0KRBjZPsiSS9g+BLCK4aW/27Q8fRv8TqeZBuPXYA3MPwSagHDlmloQD/nS7ZNlAIxDuUlpFc0naNdPxevZBu3HwLb2r66vUPSZT1PM1w/50u2TZQ5iIiIqNT0crwREdGnUiAiIqJSCkRstiTNlPQDSTdJulnS6ZKm1ziu8jnLkk4ZejCTpOMlPW2E/d4o6VeSrpF0vaT3lu2HSZpb4/tr7RexqVIgYrMkScB3KZ4kNweYA2zNJiytYftE2/+n3DweGFYgJG0BLAHeVD6H+y+Ay8ruw4A6v/jr7hexSTJJHZslSfsDH7f9mpa27SnuhZgFzAfmDT2xTdIPKR7nell5BvFVipVK7wAW2B6U9HWKq1OeA3wWWAPcaft1Ld+xE3Aj8Dzb/6+l/S/LY+8rX28B9gMWAlsCA8A7KFb6bN8PYDEwA3gIeI/tGyfkBxWbtZxBxOZqD2Cjx2Tavh9YS3H/QyfbACtt70GxIufH2z7nS8DvKJbofl1b390U6xStk3SupKMkTSkfPbkM+Efbe9v+LfBd2y8vzzRuAI4dYb8lFI/9fBnwD8AZY/5pRFTIfRARY/c4cF75/psUQ1W12X63pD2B11P8Qj+AYvXTdi+W9EmKFXm3BS5u30HStsBfAt8uRs0AGHUeJaKOFIjYXF1PMYz0hHKI6VkUQ0MvZuMz7K06fNaYx2ltXwdcJ+kc4BaqC8TXgcNsXyPpGOC1FftMAe61vfdYM0SMJkNMsbm6BHiapHcCSJpK8bCl08u5gbXA3pKmSJpFcZf1kCk8WVyOBP6j4vMfALZrb5S0raTXtjTtzZNrQLUfsx3w+3Ji+6iqzy6HxW4pn3KICnt1+o9H1JUCEZslF1dnvBmYX67BdBfwuO3/Vu5yOcVf9tcDXwKuajn8j8A+kn5NMZF8SsVXLAEukvTTtnYBH5G0RtLVwMk8efawFPjH8hLY5wP/AlxZZmmddG7f7yjgWEnXAKspns0QsclyFVMET1xFdC7wZttXjbZ/xOYgBSIiIipliCkiIiqlQERERKUUiIiIqJQCERERlVIgIiKiUgpERERU+v//KZlY8h1AQAAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "N = 3  # 设置量子比特数\n",
    "   \n",
    "# 初始化量子电路\n",
    "cir = Circuit(N)\n",
    "\n",
    "# 给每一个量子比特施加哈达玛门 H\n",
    "cir.superposition_layer()\n",
    "\n",
    "# 制备输出态\n",
    "# 如果用户不输入初始量子态，默认初始为|00..0>\n",
    "final_state = cir()\n",
    "\n",
    "# 获取概率分布的理论值，令 shots = 0\n",
    "res = final_state.measure(shots = 0, plot = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:53:12.698149Z",
     "start_time": "2021-03-09T03:53:12.187946Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "N = 3  # 设置量子比特数\n",
    "    \n",
    "# 初始化量子电路\n",
    "cir = Circuit(N)\n",
    "\n",
    "# 给每一个量子比特施加 Ry(pi/4)旋转\n",
    "cir.weak_superposition_layer()\n",
    "\n",
    "# 制备输出态\n",
    "# 如果用户不输入初始量子态，默认初始为|00..0>\n",
    "final_state = cir()\n",
    "\n",
    "# 获取概率分布的理论值，令 shots = 0\n",
    "res = final_state.measure(shots = 0, plot = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以下是一个使用频率较高的电路模板 `complex_entangled_layer(DEPTH)`，用户可按照电路深度参数 `DEPTH` 快速拓展电路。其中涉及的广义旋转门 $U_3$ 的定义为\n",
    "\n",
    "$$\n",
    "U_3(\\theta, \\phi, \\varphi) := \n",
    "\\begin{bmatrix} \n",
    "\\cos \\frac{\\theta}{2} & -e^{i \\varphi}\\sin \\frac{\\theta}{2} \\\\ \n",
    "e^{i \\phi}\\sin \\frac{\\theta}{2} &e^{i (\\phi+\\varphi)} \\cos \\frac{\\theta}{2} \n",
    "\\end{bmatrix}.\n",
    "\\tag{19}\n",
    "$$\n",
    "\n",
    "$U_3$ 旋转门在效果上是等价于以下组合旋转门的：\n",
    "\n",
    "$$\n",
    "U_3(\\theta, \\phi, \\varphi) \n",
    "= R_z(\\phi)*R_y(\\theta)*R_z(\\varphi)\n",
    ":=\n",
    "\\begin{bmatrix}\n",
    "e^{-i\\frac{\\phi}{2}} & 0 \\\\ \n",
    "0 & e^{i\\frac{\\phi}{2}}\n",
    "\\end{bmatrix}\n",
    "\\begin{bmatrix}\n",
    "\\cos \\frac{\\theta}{2} &-\\sin \\frac{\\theta}{2} \\\\ \n",
    "\\sin \\frac{\\theta}{2} &\\cos \\frac{\\theta}{2} \n",
    "\\end{bmatrix}\n",
    "\\begin{bmatrix}\n",
    "e^{-i\\frac{\\varphi}{2}} & 0 \\\\ \n",
    "0 & e^{i\\frac{\\varphi}{2}}\n",
    "\\end{bmatrix}.\\tag{20}\n",
    "$$\n",
    "\n",
    "感兴趣的读者不妨自行验证一下。\n",
    "\n",
    "<img src=\"figures/intro-fig-complex_entangled_layer2-cn.png\" width=\"850\" >\n",
    "\n",
    "特别地，当我们处理的任务不涉及虚数时，使用电路模板 `real_entangled_layer(DEPTH)` 会更加高效（$R_y$ 旋转门替代 $U_3$）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:53:14.040033Z",
     "start_time": "2021-03-09T03:53:13.566616Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "N = 4            # 设置量子比特数\n",
    "DEPTH = 6        # 设置量子电路深度\n",
    "paddle.seed(1)\n",
    "\n",
    "# 初始化量子电路\n",
    "cir = Circuit(N)\n",
    "\n",
    "# 添加深度为 D = 6 的复数强纠缠结构QNN {Rz+Ry+Rz/U3 + CNOT's}\n",
    "cir.complex_entangled_layer(depth=DEPTH)\n",
    "\n",
    "# 制备输出态\n",
    "# 如果用户不输入初始量子态，默认初始为|00..0>\n",
    "final_state = cir.forward()\n",
    "\n",
    "# 测量输出态的[0, 1, 2]号量子比特2048次，统计测量结果的频率\n",
    "res = final_state.measure(shots = 2048, qubits_idx = [0, 1, 2], plot = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>[回到 <a href=\"#Contents\">目录</a>]</p>\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a name=\"VQA\"> 变分量子算法入门 </a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"VQAOverview\"> 概览 </a> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "许多经典问题，例如旅行商问题、图像分类、找寻分子最低能级等，都可以被转化为优化问题。受限于经典计算机计算能力，许多类似的问题无法被解决。\n",
    "\n",
    "量子计算的发展，给解决以上优化问题提供了另一种可能性。在未来的几年里，具有几十到几百个量子比特的有噪中等规模量子（noisy intermediate-scale quantum, NISQ）设备极有可能变成现实。基于此类设备的变分量子算法应运而生。\n",
    "\n",
    "百度量桨平台提供了许多量子相关算法，相信通过这些例子你能对量子计算有进一步的认识，并且感受到量子计算的广泛应用前景。\n",
    "\n",
    "**为便于理解，此处我们以制备量子态为例，介绍使用变分量子算法（Variational Quantum Algorithms, VQA），即使用量子神经网络解决优化问题的基本思想与算法框架。**\n",
    "\n",
    "注：量桨电路针对纯态与混态的不同运行模式，以及飞桨优化器更一般的使用介绍，将在下两节给出。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"VQAQNN\"> 通过量子神经网络解优化问题 </a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "量子神经网络可以视作经典神经网络的量子化版本，提供了通过量子算法来解决优化问题的思路。\n",
    "\n",
    "为帮助理解，我们首先介绍优化问题以及经典神经网络的基本内容。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 经典神经网络与优化问题"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如下图所示，经典神经网络可以通过其神经元以及连结方式，相邻神经元间的权重 $\\vec{w}$ 以及偏移 $\\vec{b}$ 表示。\n",
    "\n",
    "<img src=\"./figures/intro-fig-classical_nn-cn.png\" width=\"700px\" /> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**数学上，使用经典神经网络解优化问题可以表述为：\n",
    "\t\t改变神经网络中可调参数 $\\vec{w}$, $\\vec{b}$，得到最优的输出向量 $\\hat{y} (\\vec{w},\\vec{b})$，以最小化\n",
    "\t\t损失函数 $L(\\hat{y} (\\vec{w},\\vec{b}))$。**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在旅行商问题中，损失函数可取为商人经过的总距离；在分类器问题中，损失函数可取为实际输出标签与目标输出标签的区别。\n",
    "\n",
    "<img src=\"./figures/intro-fig-tsp_and_classifier.png\" width=\"800px\" /> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 使用量子神经网络解优化问题"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "与经典神经网络不同的是，**量子神经网络使用量子态与量子门构建电路**。 \n",
    "\n",
    "一个量子神经网络，也同样可以通过其结构(电路内量子门的连结方式)，以及一组可调参数 $\\vec{\\theta}$ (对应量子门的旋转角度）来表示。\n",
    "\n",
    "<img src=\"./figures/intro-fig-vqa_qnn.png\" width=\"500px\" /> \n",
    "\n",
    "此处是一个含有三个量子比特，六个参数可调量子门，仅一层的量子神经网络。其中 $R_x(\\theta_1)$ 指一个绕 $x$-轴旋转 $\\theta_1$ 角度的量子门, $\\{\\theta_1,\\cdots,\\theta_6\\}$ 为可调参数.\n",
    "\n",
    "- 注1: 任意量子门可以被以任意精度分解为单量子比特门与双量子比特门 (例：CNOT 门)。\n",
    "- 注2: 单量子比特门总可以通过其旋转轴与旋转角度 $\\theta$ 表示。\n",
    "\t\n",
    "由以上可得，通过深度足够的量子电路并调整每一个单量子比特门旋转角度 $\\theta$，量子电路可模拟任意多量子比特门。\n",
    "\n",
    "**数学上，变分量子算法（使用量子神经网络解优化问题）可以表述为：\n",
    "通过调节（结构给定）量子神经网络中可调参数 $\\theta$，得到最优的输出量子态 $\\rho(\\vec{\\theta})$, 以及最小化损失函数 $L(\\rho(\\vec{\\theta}))$。通常输入量子态选取 $|00\\cdots0\\rangle$。**\n",
    "\n",
    "下面我们通过一个简单的例子——制备量子纯态，来展示量桨中变分量子算法的基本框架。 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 通过量桨实现举例：制备量子纯态"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当量子纯态由多量子比特组成，且具有高纠缠性时，如何得到生成所需量子态的操作将变得复杂。变分量子算法提供了一种通过学习方法解决此问题的算法。最终得到由单比特门与两比特门组合的量子电路，实现对目标量子态的制备。\n",
    "\n",
    "此处为求简单，以制备三比特量子态 $|01\\rangle\\otimes|+\\rangle$ 为例。有兴趣可以自行尝试制备更多量子比特，有纠缠的量子态。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"VQAStructure\"> 变分量子算法基本框架 </a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用量子神经网络解优化问题通常包括三步"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 步骤1：构建量子电路结构 (以函数形式)\n",
    "- 步骤1.1：构建 $N$ 量子比特线路\n",
    "- 步骤1.2：对每一层添加量子门"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 加入需要用到的包\n",
    "import paddle\n",
    "import numpy as np\n",
    "from paddle_quantum.ansatz import Circuit\n",
    "from paddle_quantum.state import State\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def circuit(N, DEPTH) -> Circuit:\n",
    "    \"\"\"\n",
    "    输入数据:\n",
    "         N,         量子比特数\n",
    "         DEPTH,     电路层数\n",
    "    返回数据:\n",
    "         cir,       最终量子电路\n",
    "    \"\"\"\n",
    "    # 步骤1.1：构建N量子比特线路\n",
    "    cir = Circuit(N)\n",
    "    # 步骤1.2：对每一层添加量子门\n",
    "    for dep in range(DEPTH):\n",
    "        for n in range(N):\n",
    "            cir.rx(n)  # 对第n个量子比特添加Rx门\n",
    "            cir.rz(n)  # 对第n个量子比特添加Rz门\n",
    "        for n in range(N - 1):\n",
    "            cir.cnot([n, n + 1])  # 对每一对临近量子比特添加CNOT门\n",
    "\n",
    "    return cir"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以下为一个例子，包含 3 量子比特，2层 QNN，可调参数 $\\theta$ 随机生成："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Rx(-1.26)----Rz(1.092)----*----Rx(2.778)----Rz(1.194)-----------------*-------\n",
      "                            |                                           |       \n",
      "--Rx(0.219)----Rz(0.882)----x--------*--------Rx(-1.00)----Rz(-1.58)----x----*--\n",
      "                                     |                                       |  \n",
      "--Rx(0.774)----Rz(-0.53)-------------x--------Rx(-1.34)----Rz(-0.88)---------x--\n",
      "                                                                                \n"
     ]
    }
   ],
   "source": [
    "N = 3\n",
    "DEPTH = 2\n",
    "cir = circuit(N, DEPTH)\n",
    "print(cir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 步骤2：设置并计算损失函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此处我们使用量子电路输出量子态与目标量子态间“-fidelity”作为损失函数。\n",
    "当输出态为我们想要的量子态时，损失函数达到最小值 -1。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loss_func(cir: Circuit, psi: State) -> paddle.Tensor:\n",
    "    final_state = cir().data\n",
    "    psi_target = psi.data\n",
    "    inner = paddle.matmul(dagger(final_state), psi_target)\n",
    "    loss = -paddle.real(paddle.matmul(dagger(inner), inner))\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 步骤3：通过优化器优化参数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通常我们选 Adam 为优化器。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iter: 0   loss: -0.0430\n",
      "iter: 10   loss: -0.8984\n",
      "iter: 20   loss: -0.9637\n",
      "iter: 30   loss: -0.9835\n",
      "iter: 40   loss: -0.9944\n",
      "iter: 50   loss: -0.9975\n",
      "iter: 60   loss: -0.9994\n",
      "iter: 70   loss: -0.9999\n",
      "iter: 80   loss: -0.9999\n",
      "iter: 90   loss: -1.0000\n",
      "iter: 100   loss: -1.0000\n",
      "iter: 110   loss: -1.0000\n"
     ]
    }
   ],
   "source": [
    "# 首先，我们给出一些训练用参数\n",
    "ITR = 115      # 学习迭代次数\n",
    "LR = 0.2       # 学习速率\n",
    "\n",
    "# 目标量子态：与步骤2中计算一致，取numpy列向量形式\n",
    "psi_vec = np.kron(np.kron(np.array([[1],[0]]), np.array([[0], [1]])), np.array([[1/np.sqrt(2)], [1/np.sqrt(2)]]))\n",
    "\n",
    "# 将目标量子态实例化为一个 State 对象\n",
    "psi_target = State(paddle.to_tensor(psi_vec).cast('complex64'))\n",
    "\n",
    "# 记录迭代中间过程:\n",
    "loss_list = []\n",
    "\n",
    "# 选择优化器，通常选用Adam\n",
    "opt = paddle.optimizer.Adam(learning_rate = LR, parameters = cir.parameters())\n",
    "\n",
    "# 迭代优化\n",
    "for itr in range(ITR):\n",
    "    # 计算损失函数\n",
    "    loss = loss_func(cir, psi_target)\n",
    "    # 通过梯度下降算法优化\n",
    "    loss.backward()\n",
    "    opt.minimize(loss)\n",
    "    opt.clear_grad()\n",
    "    # 记录学习曲线\n",
    "    loss_list.append(loss.numpy())\n",
    "    if itr % 10 == 0:\n",
    "        print('iter:', itr, '  loss: %.4f' % loss.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 步骤4：输出结果 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The minimum of the loss function:  [-0.99999565]\n",
      "Parameters after optimizationL theta:\n",
      " [array([[-3.1392097]], dtype=float32), array([[3.3646517]], dtype=float32), array([[8.64552e-05]], dtype=float32), array([[-0.05600645]], dtype=float32), array([[1.7714778]], dtype=float32), array([[1.1910632]], dtype=float32), array([[3.141264]], dtype=float32), array([[-1.0635952]], dtype=float32), array([[-0.00058735]], dtype=float32), array([[-1.9210217]], dtype=float32), array([[-0.49833927]], dtype=float32), array([[-0.42850757]], dtype=float32)] \n",
      "\n",
      "--Rx(-3.13)----Rz(3.365)----*----Rx(3.141)----Rz(-1.06)-----------------*-------\n",
      "                            |                                           |       \n",
      "--Rx(0.000)----Rz(-0.05)----x--------*--------Rx(-0.00)----Rz(-1.92)----x----*--\n",
      "                                     |                                       |  \n",
      "--Rx(1.771)----Rz(1.191)-------------x--------Rx(-0.49)----Rz(-0.42)---------x--\n",
      "                                                                                \n"
     ]
    }
   ],
   "source": [
    "# 输出最终损失函数值\n",
    "print('The minimum of the loss function: ', loss_list[-1])\n",
    "\n",
    "# 输出最终量子电路参数\n",
    "theta_final = [param.numpy() for param in cir.parameters()]\n",
    "print(\"Parameters after optimizationL theta:\\n\", theta_final, \"\\n\")\n",
    "\n",
    "# 绘制电路\n",
    "print(cir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "state_final:\n",
      " [-9.4619114e-05-1.5272114e-04j -7.3144663e-05-1.6564086e-04j\n",
      "  5.2861774e-01+4.6885246e-01j  5.2879083e-01+4.7023308e-01j\n",
      "  3.8210783e-05+1.0977582e-04j  3.8404934e-05+1.0973777e-04j\n",
      " -6.7721255e-04+5.0217507e-04j -8.2200416e-04-1.8180218e-04j]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 最终得到量子态\n",
    "state_final = cir()\n",
    "print(\"state_final:\\n\", state_final.data.numpy())\n",
    "\n",
    "# 绘制迭代过程中损失函数变化曲线\n",
    "plt.figure(1)\n",
    "ITR_list = []\n",
    "for i in range(ITR):\n",
    "    ITR_list.append(i)\n",
    "func = plt.plot(ITR_list, loss_list, alpha=0.7, marker='', linestyle='-', color='r')\n",
    "plt.xlabel('iterations')\n",
    "plt.ylabel('loss')\n",
    "plt.legend(labels=[\"loss function during iteration\"], loc='best')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可见，最终 “-fidelity” 变为 “-1”, 此时量子电路已学会如何制备目标量子态 “$|01\\rangle\\otimes|+\\rangle”$。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 练习\n",
    "- 尝试制备纠缠态。\n",
    "- 改变 “N” 制备大量子比特数的量子态。\n",
    "- 改变 \"DEPTH\" 探索学习能力与电路深度的关系。\n",
    "- 改变 “LR” 探索学习能力与学习速率的关系。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>[回到 <a href=\"#Contents\">目录</a>]</p>\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a name=\"Mode\"> 量桨的运行模式说明</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  <a name=\"vec\"> 波函数向量模式 </a>\n",
    "\n",
    "所谓的波函数模式也就是用复数向量表示和储存量子态。向量模式只能处理纯态，但这种模式在家用电脑硬件高效支持 **20+ 量子比特**的运算。用户可以测试下自己电脑的极限在哪里。在这种表示下，量子门（酉矩阵）作用在量子比特（一个复向量表示其所处状态）上本质上的运算是**矩阵乘以向量**：\n",
    "\n",
    "$$\n",
    "\\lvert {\\psi}\\rangle = U \\lvert {\\psi_0}\\rangle. \n",
    "\\tag{21}\n",
    "$$\n",
    "\n",
    "代码中，具体体现在调用 `paddle_quantum.set_backend(\"state_vector\")` 来设置运行模式为向量模式。若不指定运行模式，默认的模式为向量模式。使用代码 `final_state = cir(input_state=initial_state)` 来运行一个电路 `cir`，其输入初始态为 `initial_state`，输入态保存为 `final_state`，这两个态均为向量形式。如果我们不输入任何初始量子态，就会默认所有的量子比特都处于 $\\lvert {0}\\rangle$ 态。接着来看个具体的例子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:53:27.327236Z",
     "start_time": "2021-03-09T03:53:15.824502Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-5.4838351e-04+0.j -2.7753570e-04+0.j  6.3722655e-05+0.j ...\n",
      " -2.3885426e-04+0.j  1.8981205e-04+0.j -6.4218853e-05+0.j]\n"
     ]
    }
   ],
   "source": [
    "import paddle_quantum\n",
    "from paddle_quantum.ansatz import Circuit\n",
    "from paddle_quantum.state import zero_state, random_state\n",
    "\n",
    "N = 10           # 设置量子比特数\n",
    "DEPTH = 6        # 设置量子电路深度\n",
    "\n",
    "# 设置态向量模式\n",
    "paddle_quantum.set_backend(\"state_vector\")\n",
    "\n",
    "# 调用内置的 |00..0> 态函数来创建一个初始态\n",
    "initial_state1 = zero_state(num_qubits=N)\n",
    "# 调用内置的随机态函数来生成一个随机态\n",
    "initial_state2 = random_state(num_qubits=N)\n",
    "\n",
    "# 初始化量子电路\n",
    "cir = Circuit(N)\n",
    "\n",
    "# 添加深度为 Depth 的实数强纠缠结构QNN {Ry+CNOT's}\n",
    "cir.real_entangled_layer(depth=DEPTH)\n",
    "\n",
    "# 运行电路\n",
    "# 输入初始态为|00..0>，如果用户不输入初始量子态，默认的输入态也为|00..0>\n",
    "final_state1 = cir(initial_state1)\n",
    "print(final_state1.data.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  <a name=\"density\"> 密度矩阵模式 </a>\n",
    "\n",
    "同时 Paddle quantum也支持了密度矩阵运算模式，也就是用一个密度矩阵 $\\rho = \\sum_i P_i \\lvert {\\psi_i}\\rangle\\langle{\\psi_i} \\lvert$ 表示和储存量子态。该模式下可以根据算法需要支持**混合态模拟**。但是在密度矩阵模式下，家用电脑硬件只能运行10个左右的量子比特。请用户注意这方面的限制，我们也在不断优化这个模式下的模拟器性能。在这种表示下，量子门 (酉矩阵)作用在量子态(一个迹为1的厄尔米特矩阵)上本质上的运算是**矩阵乘法**：\n",
    "\n",
    "$$\n",
    "\\rho = U \\rho_0 U^\\dagger. \n",
    "\\tag{22}\n",
    "$$\n",
    "\n",
    "代码中，具体体现在调用 `paddle_quantum.set_backend(\"density_matrix\")` 来设置运行模式为密度矩阵模式。运行电路的方式与态向量模式相同，唯一的区别在于输入和输出态均为密度矩阵。接着来看个具体的例子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:53:27.433188Z",
     "start_time": "2021-03-09T03:53:27.333861Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.5808575 -1.0710210e-08j -0.07621858-1.5724729e-01j\n",
      "   0.3288467 +5.1938809e-02j  0.24451724-1.8499317e-03j]\n",
      " [-0.07621857+1.5724732e-01j  0.08419196-5.5879354e-09j\n",
      "  -0.05945612+7.4587353e-02j -0.01910382+7.2627157e-02j]\n",
      " [ 0.32884675-5.1938821e-02j -0.05945611-7.4587345e-02j\n",
      "   0.2059458 +1.1175871e-08j  0.12963158-5.9516393e-03j]\n",
      " [ 0.24451725+1.8499183e-03j -0.01910383-7.2627142e-02j\n",
      "   0.12963158+5.9516374e-03j  0.12900479-5.1804818e-09j]]\n"
     ]
    }
   ],
   "source": [
    "import paddle_quantum\n",
    "from paddle_quantum.ansatz import Circuit\n",
    "from paddle_quantum.state import zero_state, random_state, completely_mixed_computational\n",
    "\n",
    "N = 2            # 设置量子比特数\n",
    "DEPTH = 6        # 设置量子电路深度\n",
    "\n",
    "# 设置密度矩阵模式\n",
    "paddle_quantum.set_backend(\"density_matrix\")\n",
    "\n",
    "# 调用内置的 |00..0><00..0| 初始态\n",
    "initial_state1 = zero_state(N)\n",
    "# 调用内置的随机量子态, 可以指定是否允许复数元素和矩阵秩\n",
    "initial_state2 = random_state(N, is_real=False, rank=4)\n",
    "# 调用内置的计算基下的完全混合态 \n",
    "initial_state3 = completely_mixed_computational(N)\n",
    "\n",
    "# 初始化量子电路\n",
    "cir = Circuit(N)\n",
    "\n",
    "# 添加深度为 Depth 的实数强纠缠结构QNN {Ry+CNOT's}\n",
    "cir.real_entangled_layer(depth=DEPTH)\n",
    "\n",
    "# 制备输出态\n",
    "# 如果用户不输入初始量子态，默认初始为|00..0><00..0|\n",
    "final_state = cir(initial_state2)\n",
    "print(final_state.data.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  <a name=\"Bell\">练习：如何从计算基制备贝尔态</a>\n",
    "\n",
    "贝尔态是一种很常用的量子纠缠态，可以表示为\n",
    "\n",
    "$$\n",
    "\\lvert {\\Phi^+}\\rangle = \\frac{1}{\\sqrt{2}} \\big(\\lvert {00}\\rangle + \\lvert {11}\\rangle\\big)\n",
    "= \\frac{1}{\\sqrt{2}} \\,\n",
    "\\begin{bmatrix}\n",
    "1 \\\\\n",
    "0 \\\\\n",
    "0 \\\\\n",
    "1\n",
    "\\end{bmatrix}.\n",
    "\\tag{23}\n",
    "$$\n",
    "\n",
    "那么我们如何用量桨来制备一个贝尔态呢？只需要如下的量子电路："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"figures/intro-fig-bell2.png\" width=\"750\" >"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:53:27.924758Z",
     "start_time": "2021-03-09T03:53:27.452981Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "我们制备出的贝尔态是:\n",
      "[0.70710677+0.j 0.        +0.j 0.        +0.j 0.70710677+0.j]\n"
     ]
    }
   ],
   "source": [
    "# 设置态向量模式\n",
    "paddle_quantum.set_backend(\"state_vector\")\n",
    "\n",
    "# 初始化量子电路\n",
    "cir = Circuit(2)\n",
    "\n",
    "# 添加量子门\n",
    "cir.h(0)\n",
    "cir.cnot([0, 1])\n",
    "\n",
    "# 制备输出态\n",
    "# 如果用户不输入初始量子态，默认初始为|00..0>\n",
    "output_state = cir()\n",
    "\n",
    "# 我们测量输出态2048次，获得测量结果频率分布\n",
    "# 如果用户想获取概率分布的理论值，可以令 shots = 0\n",
    "output_state.measure(shots = 2048, plot = True)\n",
    "\n",
    "print('我们制备出的贝尔态是:')\n",
    "print(output_state.data.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>[回到 <a href=\"#Contents\">目录</a>]</p>\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a name=\"Op\"> 飞桨 Paddlepaddle 优化器使用教程</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"GD\"> 示例: 利用飞桨的梯度下降来优化多元函数</a>\n",
    "\n",
    "\n",
    "在这一节，我们学习如何用飞桨中的优化器找到一个多元函数的极小值\n",
    "\n",
    "$$\n",
    "\\mathcal{L}(\\theta_1, \\theta_2, \\theta_3)\n",
    "= (\\theta_1)^2 + (\\theta_2)^2 + (\\theta_3)^2 + 10. \n",
    "\\tag{24}\n",
    "$$\n",
    "\n",
    "可以看出，只有当 $\\theta_1 = \\theta_2 = \\theta_3 = 0$ 的时候，$\\mathcal{L}$ 取最小值 $10$。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:53:47.622260Z",
     "start_time": "2021-03-09T03:53:47.183431Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "损失函数的最小值是:  10.000000010746223\n"
     ]
    }
   ],
   "source": [
    "# 超参数设置\n",
    "theta_size = 3 \n",
    "ITR = 200       # 设置迭代次数\n",
    "LR = 0.5        # 设置学习速率\n",
    "SEED = 1        # 固定随机数种子\n",
    "paddle.seed(SEED)\n",
    "\n",
    "class Optimization_ex1(paddle.nn.Layer):\n",
    "    \n",
    "    def __init__(self, shape, dtype='float64'):\n",
    "        super(Optimization_ex1, self).__init__()\n",
    "        \n",
    "        # 初始化一个长度为 theta_size的可学习参数列表，并用 [-5, 5] 的均匀分布来填充初始值\n",
    "        self.theta = self.create_parameter(shape=shape, \n",
    "                                           default_initializer=paddle.nn.initializer.Uniform(low=-5., high=5.), \n",
    "                                           dtype=dtype, is_bias=False)\n",
    "\n",
    "    # 定义损失函数和前向传播机制\n",
    "    def forward(self):\n",
    "        loss = self.theta[0] ** 2 +  self.theta[1] ** 2 + self.theta[2] ** 2 + 10\n",
    "        return loss\n",
    "    \n",
    "# 记录中间优化结果\n",
    "loss_list = []\n",
    "parameter_list = []\n",
    "    \n",
    "# 定义网络维度\n",
    "myLayer = Optimization_ex1([theta_size])\n",
    "\n",
    "# 一般来说，我们利用Adam优化器来获得相对好的收敛，当然你可以改成SGD或者是RMSprop.\n",
    "opt = paddle.optimizer.Adam(learning_rate = LR, parameters = myLayer.parameters())    \n",
    "\n",
    "# 优化循环\n",
    "for itr in range(ITR):\n",
    "\n",
    "    # 向前传播计算损失函数\n",
    "    loss = myLayer()[0]\n",
    "\n",
    "    # 反向传播优化损失函数\n",
    "    loss.backward()\n",
    "    opt.minimize(loss)\n",
    "    opt.clear_grad()\n",
    "\n",
    "    # 记录学习曲线\n",
    "    loss_list.append(loss.numpy()[0])\n",
    "    parameter_list.append(myLayer.parameters()[0].numpy())\n",
    "\n",
    "print('损失函数的最小值是: ', loss_list[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"ex2\"> 练习: 本征值寻找</a>\n",
    "\n",
    "接下来，我们试一个更复杂的损失函数。首先我们介绍一个随机的埃尔米特矩阵 $H$，其**本征值**为矩阵 $D$ 的对角元素， \n",
    "\n",
    "$$\n",
    "D = \\begin{bmatrix} 0.2 &0 \\\\ 0 &0.8 \\end{bmatrix}. \n",
    "\\tag{25}\n",
    "$$\n",
    "\n",
    "不用担心，我们会帮你生成这个埃尔米特矩阵 $H$。\n",
    "\n",
    "然后我们初始化参数向量$\\boldsymbol{\\theta}$，构造出一个简单的线性运算 $U(\\boldsymbol{\\theta}) = R_z(\\theta_1)*R_y(\\theta_2)*R_z(\\theta_3)$：\n",
    "\n",
    "$$\n",
    "U(\\theta_1, \\theta_2, \\theta_3) = \n",
    "\\begin{bmatrix}\n",
    "e^{-i\\frac{\\theta_1}{2}} & 0 \\\\ \n",
    "0 & e^{i\\frac{\\theta_1}{2}}\n",
    "\\end{bmatrix}\n",
    "\\begin{bmatrix}\n",
    "\\cos \\frac{\\theta_2}{2} &-\\sin \\frac{\\theta_2}{2} \\\\ \n",
    "\\sin \\frac{\\theta_2}{2} &\\cos \\frac{\\theta_2}{2} \n",
    "\\end{bmatrix}\n",
    "\\begin{bmatrix}\n",
    "e^{-i\\frac{\\theta_3}{2}} & 0 \\\\ \n",
    "0 & e^{i\\frac{\\theta_3}{2}}\n",
    "\\end{bmatrix}. \n",
    "\\tag{26}\n",
    "$$\n",
    "\n",
    "我们让这个矩阵（模板）乘以 $\\lvert {0}\\rangle$，得到一个新的 2 维复向量\n",
    "\n",
    "$$ \n",
    "\\lvert {\\phi}\\rangle = U(\\theta_1, \\theta_2, \\theta_3)\\lvert {0}\\rangle. \n",
    "\\tag{27}\n",
    "$$\n",
    "\n",
    "然后，我们定义损失函数为\n",
    "\n",
    "$$\n",
    "\\mathcal{L}(\\theta_1, \\theta_2, \\theta_3) \n",
    "= \\langle{\\phi} \\lvert H \\lvert {\\phi}\\rangle \n",
    "=  \\langle{0} \\lvert  U^{\\dagger}H U \\lvert {0}\\rangle. \n",
    "\\tag{28}\n",
    "$$\n",
    "\n",
    "来看看优化后我们得到了什么！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:53:50.904606Z",
     "start_time": "2021-03-09T03:53:50.248060Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "随机生成的矩阵 H 是:\n",
      "[[0.29312716+0.j         0.20572598-0.06986022j]\n",
      " [0.20572598+0.06986022j 0.70687284+0.j        ]] \n",
      "\n",
      "不出所料，H 的本征值是:\n",
      "[0.2 0.8]\n"
     ]
    }
   ],
   "source": [
    "from scipy.stats import unitary_group\n",
    "\n",
    "# V 是一个 2x2 的随机酉矩阵\n",
    "V = unitary_group.rvs(2)\n",
    "\n",
    "# D 的对角元是H的本征值\n",
    "# 你可以任意改变这里的对角元数值\n",
    "D = np.diag([0.2, 0.8])\n",
    "\n",
    "# V_dagger 是 V 的埃尔米特转置\n",
    "V_dagger = V.conj().T\n",
    "\n",
    "# @：代表矩阵乘积运算\n",
    "H = (V @ D @ V_dagger)\n",
    "print('随机生成的矩阵 H 是:')\n",
    "print(H, '\\n')\n",
    "print('不出所料，H 的本征值是:')\n",
    "print(np.linalg.eigh(H)[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:53:50.916504Z",
     "start_time": "2021-03-09T03:53:50.908516Z"
    }
   },
   "outputs": [],
   "source": [
    "# 超参数设置\n",
    "theta_size = 3    # 设置 theta 维度\n",
    "num_qubits = 1    # 设置量子比特数\n",
    "ITR = 50          # 设置迭代次数\n",
    "LR = 0.5          # 设置学习速率\n",
    "SEED = 1          # 固定theta参数的随机数种子\n",
    "paddle.seed(SEED)\n",
    "\n",
    "# 单独设置电路模块\n",
    "def U_theta() -> Circuit:\n",
    "    \n",
    "    # 初始化电路然后添加量子门\n",
    "    cir = Circuit(num_qubits)\n",
    "    cir.rz(0)\n",
    "    cir.ry(0)\n",
    "    cir.rz(0)\n",
    "    \n",
    "    # 返回参数化电路\n",
    "    return cir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:53:54.556150Z",
     "start_time": "2021-03-09T03:53:54.489747Z"
    }
   },
   "outputs": [],
   "source": [
    "def loss_func(cir: Circuit, H: paddle.Tensor) -> paddle.Tensor:\n",
    "    # 获取量子神经网络的酉矩阵表示\n",
    "    U = cir.unitary_matrix().cast('complex64')\n",
    "    # 埃尔米特转置运算\n",
    "    U_dagger = dagger(U)\n",
    "    # 计算损失函数函数\n",
    "    loss = paddle.real(matmul(U_dagger, matmul(H, U)))[0][0]\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:53:59.114893Z",
     "start_time": "2021-03-09T03:53:58.381044Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iter: 0   loss: 0.2134\n",
      "iter: 5   loss: 0.2055\n",
      "iter: 10   loss: 0.2024\n",
      "iter: 15   loss: 0.2011\n",
      "iter: 20   loss: 0.2005\n",
      "iter: 25   loss: 0.2002\n",
      "iter: 30   loss: 0.2001\n",
      "iter: 35   loss: 0.2000\n",
      "iter: 40   loss: 0.2000\n",
      "iter: 45   loss: 0.2000\n",
      "损失函数的最小值是:  0.20000416\n"
     ]
    }
   ],
   "source": [
    "loss_list = []\n",
    "parameter_list = []\n",
    "\n",
    "cir = U_theta()\n",
    "\n",
    "# 这里采用 SGD 优化器\n",
    "opt = paddle.optimizer.SGD(learning_rate = LR, parameters = cir.parameters())    \n",
    "\n",
    "# 优化循环\n",
    "for itr in range(ITR):\n",
    "\n",
    "    # 前向传播计算损失函数\n",
    "    loss = loss_func(cir, paddle.to_tensor(H).cast('complex64'))\n",
    "\n",
    "    # 反向传播极小化损失函数\n",
    "    loss.backward()\n",
    "    opt.minimize(loss)\n",
    "    opt.clear_grad()\n",
    "\n",
    "    # 记录学习曲线\n",
    "    loss_list.append(loss.numpy()[0])\n",
    "    parameter_list.append(myLayer.parameters()[0].numpy())\n",
    "    if itr % 5 == 0:\n",
    "        print('iter:', itr, '  loss: %.4f' % loss.numpy())\n",
    "\n",
    "print('损失函数的最小值是: ', loss_list[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以改变一下 $H$ 的本征值。如果将它对角化后的的对角矩阵改变为\n",
    "\n",
    "$$\n",
    "D = \\begin{bmatrix} 0.8 &0 \\\\ 0 &1.2 \\end{bmatrix}. \n",
    "\\tag{29}\n",
    "$$\n",
    "\n",
    "你会发现我们仍然得到了 $H$ 的最小本征值 $0.8$。你能找到背后的原因吗？还是说这背后隐藏着什么理论？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>[回到 <a href=\"#Contents\">目录</a>]</p>\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a name=\"References\">参考文献</a>\n",
    "\n",
    "[1] Nielsen, M. A. & Chuang, I. L. Quantum computation and quantum information. (Cambridge university press, 2010).\n",
    "\n",
    "[2] Phillip Kaye, Laflamme, R. & Mosca, M. An Introduction to Quantum Computing. (2007).\n",
    "\n",
    "[3] Biamonte, J. et al. Quantum machine learning. [Nature 549, 195–202 (2017).](https://www.nature.com/articles/nature23474)\n",
    "\n",
    "[4] Schuld, M., Sinayskiy, I. & Petruccione, F. An introduction to quantum machine learning. [Contemp. Phys. 56, 172–185 (2015).](https://www.tandfonline.com/doi/abs/10.1080/00107514.2014.964942)\n",
    "\n",
    "[5] Benedetti, M., Lloyd, E., Sack, S. & Fiorentini, M. Parameterized quantum circuits as machine learning models. [Quantum Sci. Technol. 4, 043001 (2019).](https://iopscience.iop.org/article/10.1088/2058-9565/ab4eb5)\n",
    "\n",
    "[6] [Peruzzo, A. et al. A variational eigenvalue solver on a photonic quantum processor. Nat. Commun. 5, 4213 (2014).](https://www.nature.com/articles/ncomms5213)\n",
    "\n",
    "[7] [McClean, J. R., Romero, J., Babbush, R. & Aspuru-Guzik, A. The theory of variational hybrid quantum-classical algorithms. New J. Phys. 18, 023023 (2016).](https://iopscience.iop.org/article/10.1088/1367-2630/18/2/023023)\n",
    "\n",
    "[8] [Kandala, A. et al. Hardware-efficient variational quantum eigensolver for small molecules and quantum magnets. Nature 549, 242–246 (2017).](https://www.nature.com/articles/nature23879)\n",
    "\n",
    "[9] [Mitarai, K., Negoro, M., Kitagawa, M. & Fujii, K. Quantum circuit learning. Phys. Rev. A 98, 032309 (2018).](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.98.032309)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>[回到 <a href=\"#Contents\">目录</a>]</p>\n",
    "\n",
    "<hr>"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "QSD-Paddle.ipynb",
   "provenance": []
  },
  "interpreter": {
   "hash": "f7cfecff1ef1940b21a48efa1b88278bb096bd916f13c2df11af4810c38b47e1"
  },
  "kernelspec": {
   "display_name": "Python 3.8.0 ('pq')",
   "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.0"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "426.667px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}