introduction/PaddleQuantum_Ansatz_CN.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 利用量桨的 ansatz 模块构造量子电路\n",
    "\n",
    "_Copyright (c) 2023 Institute for Quantum Computing, Baidu Inc. All Rights Reserved._"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`ansatz` 是基于量桨推出的用于实现各种电路拟设功能的工具集。`ansatz` 为量子计算领域的研究者提供了一系列的工具，使他们可以通过设计量子电路实现量子算法等任务。同时，`ansatz` 也提供了方便开发者进行功能扩展的方式。目前 `ansatz` 仍在不断完善，您可以将需求和建议通过 GitHub 的 issue 或 pull request 反馈给我们，我们会及时给出回复。"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 搭建量子电路"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "量桨提供以下三种方式搭建量子电路：\n",
    "- **直接利用量子门构造：** 量子电路可以表示为一些单比特量子旋转门和双比特门的组合，量桨中提供了包含 $R_y, R_x, R_z$ 单比特旋转门、双比特 CNOT 门等在内的多种量子门，具体可参见[量桨 API](https://qml.baidu.com/api/paddle_quantum.ansatz.circuit.html)，利用这些量子门我们可以直接搭建量子电路；\n",
    "- **通过设置 Oracle 构造：** 除了利用量桨提供的量子门构造量子电路外，对于一些量桨上没有的量子门，我们可以以通过利用酉算子构造 Oracle 再将其放置于电路中的方式搭建量子电路；\n",
    "- **通过内置模板构造：** 量桨中提供了多种内置的参数化量子电路模板可以直接用于搭建量子电路，详细模板可参见[量桨 API](https://qml.baidu.com/api/paddle_quantum.ansatz.circuit.html)。"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "让我们从具体的例子出发了解量桨中搭建量子电路的方法，下面演示了利用 `ansatz` 中的 `Circuit` 构造量子电路。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\programs\\Anaconda\\envs\\pq\\lib\\site-packages\\openfermion\\hamiltonians\\hartree_fock.py:11: DeprecationWarning: Please use `OptimizeResult` from the `scipy.optimize` namespace, the `scipy.optimize.optimize` namespace is deprecated.\n",
      "  from scipy.optimize.optimize import OptimizeResult\n",
      "d:\\programs\\Anaconda\\envs\\pq\\lib\\site-packages\\paddle\\tensor\\creation.py:125: DeprecationWarning: `np.object` is a deprecated alias for the builtin `object`. To silence this warning, use `object` by itself. Doing this will not modify any behavior and is safe. \n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  if data.dtype == np.object:\n",
      "d:\\programs\\Anaconda\\envs\\pq\\lib\\site-packages\\paddle\\tensor\\creation.py:125: DeprecationWarning: `np.object` is a deprecated alias for the builtin `object`. To silence this warning, use `object` by itself. Doing this will not modify any behavior and is safe. \n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  if data.dtype == np.object:\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import scipy\n",
    "import paddle\n",
    "from paddle_quantum.gate import RY, RX, RZ\n",
    "from paddle_quantum.ansatz import Circuit\n",
    "from paddle_quantum.state import ghz_state\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 直接利用量子门构造量子电路"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面演示构造单比特量子电路生成量子态 $\\frac{1}{\\sqrt{2}}(\\ket{0}+\\ket{1})$。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor(shape=[2, 1], dtype=complex64, place=Place(cpu), stop_gradient=True,\n",
      "       [[(0.7071067690849304+0j)],\n",
      "        [(0.7071067690849304+0j)]])\n"
     ]
    }
   ],
   "source": [
    "# 创建单比特量子电路\n",
    "cir = Circuit(1)\n",
    "\n",
    "# 设置 Hadamard 门\n",
    "cir.h(0)\n",
    "\n",
    "# 输出量子态，量桨中默认输入态为零态\n",
    "output_state = cir()\n",
    "print(output_state.ket)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 通过设置 Oracle 构造量子电路"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面演示利用构造 Oracle 的方式构建电路实现 $e^{-i\\frac{\\phi}{2}Z}$ 的演化过程，设置输入态 $\\ket{\\psi}=\\frac{1}{\\sqrt{2}}(\\ket{0}+\\ket{1})$，则输出量子态为 $e^{-i\\frac{\\phi}{2}Z}\\ket{\\psi}$，其中 $Z$ 为 Pauli $Z$ 算符。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def oracle_cir(num_qubits: int, phi: float) -> Circuit:\n",
    "    r\"\"\" 通过设置 Oracle 的方式构造量子电路\n",
    "    \n",
    "    Args:\n",
    "        num_qubits: 量子电路的量子比特数\n",
    "        phi: 未知参数输入\n",
    "\n",
    "    Returns:\n",
    "        利用 Oracle 创建完成的量子电路\n",
    "        \n",
    "    \"\"\"\n",
    "    # 生成酉算子\n",
    "    z = np.array([[1, 0],\n",
    "                  [0, -1]])\n",
    "    oracle_unitary = paddle.to_tensor(scipy.linalg.expm(-1j * z * phi / 2))\n",
    "    # 创建量子电路\n",
    "    cir_oracle = Circuit(num_qubits)\n",
    "    # 添加 Oracle\n",
    "    cir_oracle.oracle(oracle_unitary, 0)  \n",
    "\n",
    "    return cir_oracle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "经过量子电路后的输出态为：\n",
      " Tensor(shape=[2, 1], dtype=complex64, place=Place(cpu), stop_gradient=True,\n",
      "       [[(0.6893781423568726-0.15734605491161346j)],\n",
      "        [(0.6893781423568726+0.15734605491161346j)]])\n"
     ]
    }
   ],
   "source": [
    "# 设置参数\n",
    "PHI = np.pi / 7\n",
    "NUM_QUBITS = 1\n",
    "PSI = ghz_state(1)\n",
    "CIR = oracle_cir(NUM_QUBITS, PHI)\n",
    "# 输出量子态\n",
    "print('经过量子电路后的输出态为：\\n', CIR(PSI).ket)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 内置模板构造量子电路"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面我们演示在量桨中如何利用内置模板搭建量子电路，这里我们选择的是表达能力较强的 `complex_entangled_layer`，其他模板可参见[量桨 API](https://qml.baidu.com/api/paddle_quantum.ansatz.circuit.html)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--U----*---------x--\n",
      "       |         |  \n",
      "--U----x----*----|--\n",
      "            |    |  \n",
      "--U---------x----*--\n",
      "                    \n"
     ]
    }
   ],
   "source": [
    "N = 3  # 设置量子比特数\n",
    "D = 1  # 设置内置模板的层数\n",
    "\n",
    "# 初始化量子电路\n",
    "cir_ent_layer = Circuit(N) \n",
    "# 搭建内置模板 complex_entangled_layer\n",
    "cir_ent_layer.complex_entangled_layer(depth=D)\n",
    "# 输出量子电路\n",
    "print(cir_ent_layer)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 量子电路的具体构造"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 可视化量子电路"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上一部分中输出了内置模板的量子电路，下面我们详细介绍在量桨中如何可视化量子电路。量桨提供了两种电路输出方式：`print(your_cir)` 和 `your_cir.plot()`。第一种方式由线条和量子门的符号表示，形式简单，便于展示复杂电路；第二种方式用方框表示量子门，形式直观。我们以生成 GHZ 态的电路为例，展示两种电路输出形式。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen_ghz_cir(num_qubits: int) -> Circuit:\n",
    "    r\"\"\" 生成 GHZ 态的量子电路\n",
    "    \n",
    "    Args:\n",
    "        num_qubits: 量子电路的量子比特数\n",
    "\n",
    "    Returns:\n",
    "        生成 GHZ 态的量子电路\n",
    "        \n",
    "    \"\"\"    \n",
    "    # 创建量子电路\n",
    "    ghz_cir = Circuit(num_qubits)\n",
    "    # 设置 Hadamard 门\n",
    "    ghz_cir.h(0)\n",
    "    # 设置 CNOT 门\n",
    "    for i in range(1, num_qubits):\n",
    "        ghz_cir.cnot([0, i])\n",
    "\n",
    "    return ghz_cir"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面我们利用构造的电路生成 $3$ 量子比特的 GHZ 态 $\\frac{1}{\\sqrt{2}}(\\ket{000}+\\ket{111})$。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "经过量子电路后的输出态为：\n",
      " Tensor(shape=[8, 1], dtype=complex64, place=Place(cpu), stop_gradient=True,\n",
      "       [[(0.7071067690849304+0j)],\n",
      "        [0j                     ],\n",
      "        [0j                     ],\n",
      "        [0j                     ],\n",
      "        [0j                     ],\n",
      "        [0j                     ],\n",
      "        [0j                     ],\n",
      "        [(0.7071067690849304+0j)]])\n"
     ]
    }
   ],
   "source": [
    "# 调用生成 GHZ 态的函数\n",
    "ghz_3_cir = gen_ghz_cir(3)\n",
    "# 输出量子态，量桨默认输入态为零态\n",
    "ghz_3_state = ghz_3_cir()\n",
    "print('经过量子电路后的输出态为：\\n', ghz_3_state.ket)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可视化量子电路的两种方式："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第一种量子电路输出方式：\n",
      "\n",
      "--H----*----*--\n",
      "       |    |  \n",
      "-------x----|--\n",
      "            |  \n",
      "------------x--\n",
      "               \n",
      "第二种量子电路输出方式：\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 104x165 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 输出量子电路\n",
    "print('第一种量子电路输出方式：')\n",
    "print()\n",
    "print(ghz_3_cir)\n",
    "print('第二种量子电路输出方式：\\n')\n",
    "ghz_3_cir.plot()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 量子门的一般性构造"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来，我们以在量子电路中设置单比特 $R_y, R_x, R_z$ 门和两比特 CNOT 门为例，展示如何进行添加或删减量子门的一般性构造。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "添加量子门后的电路为：\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 294x165 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "删除量子门后的电路为：\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 204x165 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 创建 3 量子比特电路\n",
    "cir = Circuit(3)\n",
    "# 设置参数并自定义量子门，这里我们选择 Ry, Rx, Rz 门\n",
    "param = np.random.rand(2)\n",
    "ry_gate = RY(param=param, qubits_idx=[0, 2])  # 参数可选填，默认情况下 RY 类随机生成一组参数\n",
    "rx_gate = RX(param=param, qubits_idx=[0, 1])\n",
    "rz_gate = RZ(param=param, qubits_idx=[1, 2])\n",
    "# 在量子电路中插入量子门\n",
    "cir.append(ry_gate)\n",
    "cir.append(rx_gate)\n",
    "cir.insert(index=2, operator=rz_gate)  # index 指定插入的位置，operator 指定插入的量子门\n",
    "# 输出量子电路，这里我们选择较直观的 plot 方法\n",
    "print('添加量子门后的电路为：')\n",
    "cir.plot()\n",
    "\n",
    "# 在量子电路中删除 Rx 门\n",
    "cir.pop(index=1, operator=rx_gate)  # index 指定删除的位置，operator 指定删除的量子门，该参数可选择输入\n",
    "print('删除量子门后的电路为：')\n",
    "cir.plot()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "除了利用 `append` 这类方法插入量子门外，还可以用下述方式实现量子门的设置："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 414x165 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 创建 3 量子比特电路\n",
    "cir = Circuit(3)\n",
    "# 设置参数\n",
    "theta = np.full([2], np.pi)\n",
    "# 设置量子门\n",
    "# 单量子比特 Ry 门\n",
    "cir.ry(qubits_idx='full', param=theta[0])  # qubits_idx='full' 指定量子门作用在所有编号的量子比特上，单比特量子门的 qubits_idx 默认为 full；param 指定输入参数，默认情况下由 Ry 门随机生成\n",
    "# 两量子比特 CNOT 门\n",
    "cir.cnot(qubits_idx='linear')  # qubits_idx='linear' 指定量子门作用方式为 linear，多比特量子门的 qubits_idx 默认为 cycle\n",
    "# 单量子比特 Rx 门\n",
    "cir.rx(qubits_idx='even')  # qubits_idx='even' 指定量子门作用在编号为偶数的量子比特上，默认为 full；param 指定输入参数，默认情况下由 Rx 门随机生成\n",
    "# 两量子比特 CNOT 门\n",
    "cir.cnot(qubits_idx='cycle')  # qubits_idx='cycle' 指定量子门作用方式为 cycle，多比特量子门的 qubits_idx 默认为 cycle\n",
    "# 单量子比特 Rz 门\n",
    "cir.rz(qubits_idx='odd', param=theta[1])  # qubits_idx='odd' 指定量子门作用在编号为奇数的量子比特上，默认为 full；param 指定输入参数，默认情况下由 Rz 门随机生成\n",
    "# 两量子比特 CNOT 门\n",
    "cir.cnot([0, 2])  # qubits_idx 为 list 指定量子门作用在编号为 0 和 2 的量子比特上，其中 0 为控制位 2 为受控位\n",
    "# 输出量子电路\n",
    "cir.plot()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "前面提到的构造量子电路都需要给定量子电路大小，即量子比特数，除了这种方式外，量桨还提供了不需要输入量子比特数的动态电路构造方式，下面我们给出一简单示例来展示该类型电路的构造方法。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 154x110 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 324x220 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cir = Circuit()  # 未指定电路大小\n",
    "cir.ry([0, 1])  # 电路大小更新为 2\n",
    "cir.h()  # 以总比特数为 2 设置 Hadamard 门\n",
    "cir.plot()  # 绘制此时的 2 比特电路\n",
    "cir.rx([2, 3])  # 电路大小根据量子门的添加更新为 4\n",
    "cir.cnot()  # 以总比特数为 4 设置 CNOT 门\n",
    "cir.plot()  # 绘制更新后的 4 比特电路"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "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.13"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}