introduction/PaddleQuantum_Ansatz_EN.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Construct Quantum Circuits with Paddle Quantum's ansatz\n",
    "\n",
    "_Copyright (c) 2023 Institute for Quantum Computing, Baidu Inc. All Rights Reserved._"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`ansatz`, which builds on top of Paddle Quantum, is designed to be a toolkit for implementing various quantum circuits. It provides high level APIs for researchers who are interested in implementing quantum algorithm with quantum circuits. At the same time, `ansatz` also provides a convenient way for developers to extend the functionality. `ansatz` is currently under active development, feel free to join us by opening issues or pull requests."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Construct the quantum circuits"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Paddle Quantum provides the following three ways to build quantum circuits:\n",
    "\n",
    "- **Direct construction of quantum circuits using quantum gates.** Quantum circuit can be expressed as a combination of single-qubit quantum gates and two-qubit gates. Paddle Quantum provides a variety of quantum gates including $R_y, R_x, R_z$ single-qubit gate, two-qubit CNOT gate, etc. Specific details can see [API of Paddle Quantum](https://qml.baidu.com/api/paddle_quantum.ansatz.circuit.html). Using these quantum gates we can directly to create quantum circuits.\n",
    "\n",
    "- **Use oracle to construct quantum circuits.** In addition to constructing quantum circuits using quantum gates provided by Paddle Quantum, we can also construct quantum circuits using the oracle of a unitary, then implement it in the circuit. \n",
    "\n",
    "- **Use built-in circuit templates to construct quantum circuits.** Paddle Quantum provides some built-in circuit templates to make user's life easier. For more templates, see [API of Paddle Quantum](https://qml.baidu.com/api/paddle_quantum.ansatz.circuit.html)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start from a specific example to understand the way to construct a quantum circuit in Paddle Quantum. First we import the necessary packages."
   ]
  },
  {
   "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": [
    "### Directly construction of quantum circuits using quantum gates."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code demonstrates the construction of a single-qubit quantum circuit to generate $\\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": [
    "# Create a single qubit circuit\n",
    "cir = Circuit(1)\n",
    "\n",
    "# Set the Hadamard gate\n",
    "cir.h(0)\n",
    "\n",
    "# Output quantum circuit\n",
    "output_state = cir()\n",
    "print(output_state.ket)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Use oracle to construct quantum circuits"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use the oracle of $e^{-i\\frac{\\phi}{2}Z}$ to evolve the input state $\\ket{\\psi}=\\frac{1}{\\sqrt{2}}(\\ket{0}+\\ket{1})$. Then the output state is $e^{-i\\frac{\\phi}{2}Z}\\ket{\\psi}$, where $Z$ is Pauli $Z$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def oracle_cir(num_qubits: int, phi: float) -> Circuit:\n",
    "    r\"\"\" Use oracle to construct quantum circuits\n",
    "    \n",
    "    Args:\n",
    "        num_qubits: the number of qubits\n",
    "        phi: unknown parameter\n",
    "\n",
    "    Returns:\n",
    "        Circuit\n",
    "        \n",
    "    \"\"\"    \n",
    "    # Create the unitary\n",
    "    z = np.array([[1, 0],\n",
    "                  [0, -1]])\n",
    "    oracle_unitary = paddle.to_tensor(scipy.linalg.expm(-1j * z * phi / 2))\n",
    "    # Create a quantum circuit\n",
    "    cir_oracle = Circuit(num_qubits)\n",
    "    # Implement the oracle into the circuit \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": [
      "The output state is \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": [
    "# Set parameters\n",
    "PHI = np.pi / 7\n",
    "NUM_QUBITS = 1\n",
    "PSI = ghz_state(1)\n",
    "CIR = oracle_cir(NUM_QUBITS, PHI)\n",
    "# Output state\n",
    "print('The output state is \\n', CIR(PSI).ket)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Use built-in circuit templates to construct quantum circuits"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we demonstrate how to build a quantum circuit using built-in circuit templates. We choose the `complex_entangled_layer`. For other templates, see [API of Paddle Quantum](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  # The number of qubits\n",
    "D = 1  # The depth of the template\n",
    "\n",
    "# Initialize the quantum circuit\n",
    "cir_ent_layer = Circuit(N) \n",
    "# Construct complex_entangled_layer\n",
    "cir_ent_layer.complex_entangled_layer(depth=D)\n",
    "# Print circuit\n",
    "print(cir_ent_layer)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Specific circuit construction"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize circuit"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous section, we print the built-in template. Now we describe in detail how to visualize the circuit in Paddle Quantum. Two circuit output modes are provided: `print(your_cir)` and `your_cir.plot()`. The first method is represented by lines and symbols, which is simple in form and easy to show complex circuits. The second one is to use a box to represent the quantum gate, the form is more intuitive than the first one. We take a circuit generating the GHZ state as an example in the following to show two circuit output modes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen_ghz_cir(num_qubits: int) -> Circuit:\n",
    "    r\"\"\" Quantum circuit to generate GHZ state\n",
    "    \n",
    "    Args:\n",
    "        num_qubits: the number of qubits\n",
    "\n",
    "    Returns:\n",
    "        Circuit\n",
    "        \n",
    "    \"\"\" \n",
    "    # Create a quantum circuit\n",
    "    ghz_cir = Circuit(num_qubits)\n",
    "    # Add the Hadamard gate to the first qubit\n",
    "    ghz_cir.h(0)\n",
    "    # Add CNOT gates\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": [
    "Using the constructed circuit to generate $3$-qubit GHZ state $\\frac{1}{\\sqrt{2}}(\\ket{000}+\\ket{111})$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The output state is\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": [
    "# Use the function that generates the GHZ state\n",
    "ghz_3_cir = gen_ghz_cir(3)\n",
    "# Output quantum state\n",
    "ghz_3_state = ghz_3_cir()\n",
    "print('The output state is\\n', ghz_3_state.ket)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two ways to visualize quantum circuits:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First way to show the circuit:\n",
      "\n",
      "--H----*----*--\n",
      "       |    |  \n",
      "-------x----|--\n",
      "            |  \n",
      "------------x--\n",
      "               \n",
      "Second way to show the circuit: \n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 104x165 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Print circuits\n",
    "print('First way to show the circuit:')\n",
    "print()\n",
    "print(ghz_3_cir)\n",
    "print('Second way to show the circuit: \\n')\n",
    "ghz_3_cir.plot()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### General construction of quantum gates"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we take $R_y, R_x, R_z$ and CNOT gates as an example to show a general construction of how to add or remove gates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The quantum circuit after adding gates is: \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": [
      "The quantum circuit after removing gates is:\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 204x165 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Initialize a 3-qubit quantum circuit\n",
    "cir = Circuit(3)\n",
    "# Set parameters and customize quantum gates. Here we select Ry, Rx, Rz gates\n",
    "param = np.random.rand(2)\n",
    "ry_gate = RY(param=param, qubits_idx=[0, 2])  # By default, Ry randomly generates a set of parameters\n",
    "rx_gate = RX(param=param, qubits_idx=[0, 1])\n",
    "rz_gate = RZ(param=param, qubits_idx=[1, 2])\n",
    "# Add quantum gates\n",
    "cir.append(ry_gate)\n",
    "cir.append(rx_gate)\n",
    "cir.insert(index=2, operator=rz_gate)  # index specifies where to insert, and operator specifies which quantum gate to insert\n",
    "# Print quantum gate\n",
    "print('The quantum circuit after adding gates is: ')\n",
    "cir.plot()\n",
    "\n",
    "# Remove Rx gate\n",
    "cir.pop(index=1, operator=rx_gate)  # index specifies where to remove, and operator specifies which quantum gate to remove\n",
    "print('The quantum circuit after removing gates is:')\n",
    "cir.plot()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to inserting a quantum gate using methods such as `append`, it can also be realized in the following ways:"
   ]
  },
  {
   "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": [
    "# Initialize a 3-qubit quantum circuit\n",
    "cir = Circuit(3)\n",
    "# Set parameters\n",
    "theta = np.full([2], np.pi)\n",
    "# Add quantum gates\n",
    "# Add single-qubit gate Ry \n",
    "cir.ry(qubits_idx='full', param=theta[0])  # qubits_idx='full': specifies that all qubits are applied, defaults qubits_idx of the single-qubit gate to 'cycle'. param: parameters of the gates, defaults to None, i.e., randomly generated by Ry gate.\n",
    "# Add two-qubit gate CNOT\n",
    "cir.cnot(qubits_idx='linear')  # qubits_idx='linear': specifies that the implement of the CNOT gate is linear, default qubits_idx of the multi-qubit quantum gate is cycle.\n",
    "# Add single qubit gate Rx \n",
    "cir.rx(qubits_idx='even')  # qubits_idx='even': specifies that even number of qubits are applied, defaults of single-qubit gate to 'cycle'. param: parameters of the gates, defaults to None, i.e., randomly generated by Rx gate.\n",
    "# Add two-qubit gate CNOT\n",
    "cir.cnot(qubits_idx='cycle')  # qubits_idx='cycle': specifies that the implement of the CNOT gate is cycle, default qubits_idx of the multi-qubit quantum gate is cycle.\n",
    "# Add single qubit gate Rz\n",
    "cir.rz(qubits_idx='odd', param=theta[1])  # qubits_idx='odd': specifies that odd number of qubits are applied, defaults of single-qubit gate to 'cycle'. param: parameters of the gates, defaults to None, i.e., randomly generated by Rz gate.\n",
    "# Add two-qubit gate CNOT\n",
    "cir.cnot([0, 2])  # qubits_idx is [0, 2] that specifies the CNOT acting on qubits numbered 0 and 2, where 0 is the control qubit and 2 is the target qubit.\n",
    "# Print circuit\n",
    "cir.plot()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The quantum circuit construction mentioned above requires a given circuit size, that is, qubit number. In addition to this way, Paddle Quantum also provides a dynamic circuit construction method that does not require input qubit number. The following is a simple example to demonstrate this method."
   ]
  },
  {
   "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()  # Do not give a qubit number\n",
    "cir.ry([0, 1])  # The size of this circuit is updated to 2\n",
    "cir.h()  # Set Hadamard gates\n",
    "cir.plot()  # Draw this 2-qubit circuit\n",
    "cir.rx([2, 3])  # The size of this circuit is updated to 4 because of the added Rx gates\n",
    "cir.cnot()  # Set CNOT gates\n",
    "cir.plot()  # Draw the updated 4-qubit circuit"
   ]
  }
 ],
 "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
}