SimulateHeisenberg_EN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9d3716bb",
   "metadata": {},
   "source": [
    "# Simulate the Spin Dynamics on a Heisenberg Chain\n",
    "\n",
    "<em> Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. </em>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0832e9f",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "The simulation of quantum systems is one of the many important applications of quantum computers. In general, the system's properties are characterized by its Hamiltonian operator $H$. For physical systems at different scales, their Hamiltonian takes different forms. For example in quantum chemistry, where we are often interested in the properties of molecules, which are determined mostly by electron-electron Coulomb interactions. As a consequence, a molecular Hamiltonian is usually written in the form of fermionic operators which act on the electron's wave function. On the other hand, the basic computational unit of a quantum computer - qubit, and its corresponding operations, correspond to spin and spin operators in physics.  So in order to simulate a molecular Hamiltonian on a quantum computer, one needs to first map fermionic operators into spin operators with mappings such as Jordan-Wigner or Bravyi-Kitaev transformation, etc. Those transformations often create additional overhead for quantum simulation algorithms, make them more demanding in terms of a quantum computer's number of qubits, connectivity, and error control. It was commonly believed that one of the most near-term applications for quantum computers it the simulation of quantum spin models, whose Hamiltonian are natively composed of Pauli operators. \n",
    "\n",
    "This tutorial will demonstrate how to simulate the time evolution process of a one-dimensional Heisenberg chain, one of the most commonly studied quantum spin models. This tutorial is based on the `construct_trotter_circuit()`, which can construct the Trotter-Suzuki or any custom trotterization circuit to simulate the time-evolving operator. We have already covered some of the basic usage as well as the theoretical background in another tutorial [Hamiltonian Simulation with Product Formula](./HamiltonianSimulation_EN.ipynb). A brief introduction of the Suzuki product formula is provided below for readers who are not familiar with it. In the remainder of this tutorial, we will be focusing on two parts:\n",
    "- Simulating the spin dynamics on a Heisenberg chain\n",
    "- Using randomized permutation to build a custom trotter circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "988b3a47",
   "metadata": {},
   "source": [
    "---\n",
    "Before discussing the physical background of the Heisenberg model, let's go over the basic concepts of time evolution simulation with a quantum circuit. Readers already familiar with this or uninterested in such details could choose to skip to the section of **Heisenberg model and its dynamical simulation** to continue reading.\n",
    "\n",
    "### Simulate the time evolution with Suzuki product formula\n",
    "\n",
    "The core idea of the Suzuki product formula can be described as follows: First, for a time-independent Hamiltonian $H = \\sum_k^L h_k$, the system's time evolution operator is \n",
    "\n",
    "$$\n",
    "U(t) = e^{-iHt}.\n",
    "\\tag{1}\n",
    "$$\n",
    "\n",
    "Further dividing it into $r$ pieces, we have\n",
    "\n",
    "$$\n",
    "e^{-iHt} = \\left( e^{-iH \\tau} \\right)^r, ~\\tau=\\frac{t}{r}.\n",
    "\\tag{2}\n",
    "$$\n",
    "\n",
    "This strategy is sometimes referred to as \"Totterization\". \n",
    "\n",
    "And for each $e^{-iH \\tau}$ operator, its Suzuki decompositions are\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "S_1(\\tau) &= \\prod_{k=0}^L \\exp ( -i h_k \\tau),\n",
    "\\\\\n",
    "S_2(\\tau) &= \\prod_{k=0}^L \\exp ( -i h_k \\frac{\\tau}{2})\\prod_{k=L}^0 \\exp ( -i h_k \\frac{\\tau}{2}),\n",
    "\\\\\n",
    "S_{2k+2}(\\tau) &= [S_{2k}(p_k\\tau)]^2S_{2k}\\left( (1-4p_k)\\tau\\right)[S_{2k}(p_k\\tau)]^2.\n",
    "\\end{aligned}\n",
    "\\tag{3}\n",
    "$$\n",
    "\n",
    "Back to the original time evolution operator $U(t)$, with the $k$-th order Suzuki decomposition, it can be reformulated as\n",
    "\n",
    "$$\n",
    "U(t) = e^{-iHt} = \\left( S_{k}\\left(\\frac{t}{r}\\right) \\right)^r.\n",
    "\\tag{4}\n",
    "$$\n",
    "\n",
    "The above scheme is referred to as the Suzuki product formula or Trotter-Suzuki decomposition. It is proven that it could efficiently simulate any time evolution process of a system with a k-local Hamiltonian up to arbitrary precision [1]. In another tutorial [Hamiltonian Simulation with Product Formula](./HamiltonianSimulation_EN.ipynb), we have shown how to calculate its error upper bound.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab3f7311",
   "metadata": {},
   "source": [
    "## Heisenberg Model and Its Dynamic Simulation\n",
    "\n",
    "The Heisenberg model is arguably one of the most commonly used model in the research of quantum magnetism and quantum many-body physics. Its Hamiltonian can be expressed as \n",
    "\n",
    "$$\n",
    "H = \\sum_{\\langle i, j\\rangle} \n",
    "\\left( J_x S^x_{i} S^x_{j} + J_y S^y_{i} S^y_{j} + J_z S^z_{i} S^z_{j} \\right)\n",
    "+\n",
    "\\sum_{i} h_z S^z_i, \n",
    "\\tag{5}\n",
    "$$\n",
    "\n",
    "with $\\langle i, j\\rangle$ depends on the specific lattice structure, $J_x, J_y, J_z$ describe the spin coupling strength respectively in the $xyz$ directions and $h_z$ is the magnetic field applied along the $z$ direction. When taking $J_z = 0$, the Hamiltonian in (5) can be used to describe the XY model; or when taking $J_x = J_y = 0$, then (5) is reduced to the Hamiltonian of Ising model. Note that here we used a notation of many-body spin operators $S^x_i, S^y_i, S^z_i$ which act on each of the local spins, this is slightly different from our usual notations but are very common in the field of quantum many-body physics. For a spin-1/2 system, when neglecting a coefficient of $\\hbar/2$, the many-body spin operators are simple tensor products of Pauli operators, i.e.\n",
    "\n",
    "$$\n",
    "S^P_{i} = \\left ( \\otimes_{j=0}^{i-1} I \\right ) \\otimes \\sigma_{P} \\otimes \\left ( \\otimes_{j=i+1}^{L} I \\right ),\n",
    "P \\in \\{ x, y, z \\},\n",
    "\\tag{6}\n",
    "$$\n",
    "\n",
    "where the $\\sigma_{P}$ are Pauli operators, which can also be represented as $XYZ$. It is worth noting that while the Heisenberg model is an important theoretical model, but it also describes the physics in realistic materials (crystals). Starting from the Hubbard model, which describes the interactions and movement of electrons on a lattice, under certain conditions, the electrons are fixed to each site and form a half-filling case. In this case, the only left-over interaction is an effective spin-spin exchange interaction and the Hubbard model is reduced to the Heisenberg model [2]. While it seems that many approximations are made, the Heisenberg model has successfully described the properties of many crystal materials at low temperatures [3]. For example, many readers might be familiar with the copper nitrate crystal ($\\rm Cu(NO_3)_2 \\cdot 2.5 H_2 O$), and its behavior at $\\sim 3k$ can be described by an alternating spin-1/2 Heisenberg chain [4].\n",
    "\n",
    "Depending on the lattice structure, the Heisenberg model can host highly non-trivial quantum phenomena. As a one-dimensional chain, it demonstrates ferromagnetism and anti-ferromagnetism, symmetry breaking and gapless excitations [3]. On frustrated two-dimension lattices, some Heisenberg models constitute candidate models for quantum spin liquids, a long-range entangled quantum matter [5]. When under a disordered external magnet field, the Heisenberg model also can be used in the research of a heated topic, many-body localization, where the system violates the thermalization hypothesis and retains memories of its initial state after infinitely long time's evolution [6]. \n",
    "\n",
    "Simulating the time evolution of a Heisenberg model, i.e. the dynamical simulation, could help us to investigate the non-equilibrium properties of the system, and it might help us to locate novel quantum phases such as the many-body localized (MBL) phase introduced above or even more interestingly, time crystal phases [7]. Other than developing theories, the dynamic simulation plays a vital role for experimentalists, as the spin correlation function (also referred to as dynamical structure factors) is directly linked to the cross sections for scattering experiments or line shapes in nuclear magnetic resonance (NMR) experiments [3]. And this function, which we omit its exact form here, is a function of integration over $\\langle S(t) S(0) \\rangle$. So that in order to bridge the experiment and theory, one also need to compute the system's evolution in time.\n",
    "\n",
    "### Use Paddle Quantum to simulate and observe the time evolution process of a Heisenberg chain"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca09d58d",
   "metadata": {},
   "source": [
    "Now, we will take a one dimensional Heisenberg chain under disordered field of length 5 as an example, and demonstrate how the construct its time evolving circuit in Paddle Quantum. First we need to import relevant packages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5c873819",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy\n",
    "from scipy import linalg\n",
    "import matplotlib.pyplot as plt\n",
    "from paddle_quantum.circuit import UAnsatz\n",
    "from paddle_quantum.utils import SpinOps, Hamiltonian, gate_fidelity\n",
    "from paddle_quantum.trotter import construct_trotter_circuit, get_1d_heisenberg_hamiltonian"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d96d3bcb",
   "metadata": {},
   "source": [
    "Then we use `get_1d_heisenberg_hamiltonian()` function to generate the Hamiltonian of a Heisenberg chain."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "88fa56fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Hamiltoninan is:\n",
      "1.0 X0, X1\n",
      "1.0 Y0, Y1\n",
      "2.0 Z0, Z1\n",
      "1.0 X1, X2\n",
      "1.0 Y1, Y2\n",
      "2.0 Z1, Z2\n",
      "1.0 X2, X3\n",
      "1.0 Y2, Y3\n",
      "2.0 Z2, Z3\n",
      "1.0 X3, X4\n",
      "1.0 Y3, Y4\n",
      "2.0 Z3, Z4\n",
      "0.30554627625735065 Z0\n",
      "0.6025258365109716 Z1\n",
      "-0.1545550348192246 Z2\n",
      "0.9823722719316286 Z3\n",
      "-0.6157481417955128 Z4\n"
     ]
    }
   ],
   "source": [
    "h = get_1d_heisenberg_hamiltonian(length=5, j_x=1, j_y=1, j_z=2, h_z=2 * np.random.rand(5) - 1,\n",
    "                                  periodic_boundary_condition=False)\n",
    "print('The Hamiltoninan is:')\n",
    "print(h)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0793414b",
   "metadata": {},
   "source": [
    "After obtaining its Hamiltonian, we can then pass it to the `construct_trotter_circuit()` function to construct its time evolution circuit. Also, with `Hamiltonian.construct_h_matrix()` who returns the matrix form of a `Hamiltonian` object, we can calculate its exponential, i.e. the exact time-evolving operator. By taking the quantum circuit's unitary matrix `UAnsatz.U` and comparing it to the exact time-evolving operator by calculating their fidelity, we can evaluate how well the constructed circuit could describe the correct time evolution process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5052fb32",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The fidelity between the circuit's unitary and the exact evolution operator is : 0.58\n"
     ]
    }
   ],
   "source": [
    "# calculate the exact evolution operator of time t\n",
    "def get_evolve_op(t): return scipy.linalg.expm(-1j * t * h.construct_h_matrix())\n",
    "\n",
    "# set the total evolution time and the number of trotter steps\n",
    "t = 3\n",
    "r = 10\n",
    "# construct the evolution circuit\n",
    "cir_evolve = UAnsatz(5)\n",
    "construct_trotter_circuit(cir_evolve, h, tau=t/r, steps=r, order=2)\n",
    "# get the circuit's unitary matrix and calculate its fidelity to the exact evolution operator\n",
    "U_cir = cir_evolve.U.numpy()\n",
    "print('The fidelity between the circuit\\'s unitary and the exact evolution operator is : %.2f' % gate_fidelity(get_evolve_op(t), U_cir))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce487d74",
   "metadata": {},
   "source": [
    "#### Permute the Hamiltonian according to commutation relationships\n",
    "\n",
    "It has been shown that the product formula's simulating error can be reduced by rearranging different terms. Since the error of simulation arises from the non-commuting terms in the Hamiltonian, one natural idea is to permute the Hamiltonian so that commuting terms are put together. For example, we could divide a Hamiltonian into four parts,\n",
    "\n",
    "$$\n",
    "H = H_x + H_y + H_z + H_{\\rm other},\n",
    "\\tag{7}\n",
    "$$\n",
    "\n",
    "where $H_x, H_y, H_z$ contain terms only composed of $X, Y, Z$ operators, and $H_{\\rm other}$ are all the other terms. For Hamiltonian describe in (5), all terms can be grouped into $H_x, H_y, H_z$.\n",
    "\n",
    "Another approach is to decompose the Hamiltonian according to the system geometry. Especially for one-dimensional nearest-neighbor systems, the Hamiltonian can be divided into even and odd terms, \n",
    "\n",
    "$$\n",
    "H = H_{\\rm even} + H_{\\rm odd}.\n",
    "\\tag{8}\n",
    "$$\n",
    "\n",
    "where $H_{\\rm even}$ are interactions on sites $(0, 1), (2, 3), ...$ and $H_{\\rm odd}$ are interactions on sites $(1, 2), (3, 4), ...$.\n",
    "\n",
    "Note that these two permutation strategies do **not** reduce the bound on simulation error, and empirical results return a more case-by-case effect on the error. Nevertheless, we provide the above two decompositions as a built-in option of the `construct_trotter_circuit()` function. By setting the argument `grouping='xyz'` or `grouping='even_odd'`, the function will automatically try to rearrange the Hamiltonian when adding the trotter circuit. Besides, users can also customize permutation by using the argument `permutation`, which we will introduce shortly in the next section. For now, let's test the `grouping` option and check the variations in fidelity:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b2eaca4c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original fidelity： 0.5777594967189371\n",
      "XYZ permuted fidelity： 0.7009189629323416\n",
      "Even-odd permuted fidelity： 0.7301965802081132\n"
     ]
    }
   ],
   "source": [
    "# using the same evolution parameters, but set 'grouping=\"xyz\"' and 'grouping=\"even_odd\"'\n",
    "cir_evolve_xyz = UAnsatz(5)\n",
    "cir_evolve_even_odd = UAnsatz(5)\n",
    "construct_trotter_circuit(cir_evolve_xyz, h, tau=t/r, steps=r, order=2, grouping='xyz')\n",
    "construct_trotter_circuit(cir_evolve_even_odd, h, tau=t/r, steps=r, order=2, grouping='even_odd')\n",
    "U_cir_xyz = cir_evolve_xyz.U.numpy()\n",
    "U_cir_even_odd = cir_evolve_even_odd.U.numpy()\n",
    "print('Original fidelity：', gate_fidelity(get_evolve_op(t), U_cir))\n",
    "print('XYZ permuted fidelity：', gate_fidelity(get_evolve_op(t), U_cir_xyz))\n",
    "print('Even-odd permuted fidelity：', gate_fidelity(get_evolve_op(t), U_cir_even_odd))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f18e3f16",
   "metadata": {},
   "source": [
    "#### Initial state preparation and final state observation\n",
    "\n",
    "Now let's prepare the system's initial state. Generally speaking, one common approach when studying the dynamics of a quantum system is to start the evolution from different direct product states. In Paddle Quantum, the default initial state is $\\vert 0...0 \\rangle$, so we can simply apply $X$ gate to different qubits to get a direct product initial state. For example, here we apply $X$ gate to qubits representing spins on odd sites, so the initial state will become $\\vert 01010 \\rangle$, as in spin notation, $\\vert \\downarrow \\uparrow \\downarrow \\uparrow \\downarrow \\rangle$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e0ff6736",
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a circuit used for initial state preparation\n",
    "cir = UAnsatz(5)\n",
    "cir.x(1)\n",
    "cir.x(3)\n",
    "# run the circuit the get the initial state\n",
    "init_state = cir.run_state_vector()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7d5b832",
   "metadata": {},
   "source": [
    "By passing the initial state `init_state` into the method `UAnsatz.run_state_vector(init_state)`, we can evolve the initial state with a quantum circuit. Then by `UAnsatz.expecval()` method, the expectation value of a user-specified observable on the final state could be measured. For simplicity, we only consider a single-spin observable $\\langle S_i^z \\rangle$ here, its corresponding Pauli string is `[[1, 'Zi']]` (i being an integer)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "88d5e1b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sz observable on the site 0 is： 0.6516225940072864\n"
     ]
    }
   ],
   "source": [
    "cir_evolve_even_odd.run_state_vector(init_state)\n",
    "print('Sz observable on the site 0 is：', cir_evolve_even_odd.expecval([[1, 'Z0']]).numpy()[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e70d9fba",
   "metadata": {},
   "source": [
    "Similarly, by adjusting the simulation time length and changing the observable, we could plot the entire evolution process of different spins. Note here in order to compute the exact solution, we need to construct the matrix form of each observable $S_i^z$ using `SpinOps` class and calculate their expectation value with $\\langle \\psi(t) \\vert S_i^z \\vert \\psi(t) \\rangle$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6c4c03ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_evolution_z_obs(h, t_total, order=None, n_steps=None, exact=None):\n",
    "    \"\"\" \n",
    "    a function to calculate a system's Sz observable on each site for an entire evolution process t\n",
    "    specify the order the trotter length by setting order and n_steps\n",
    "    set exact=True to get the exact results\n",
    "    \"\"\"\n",
    "    z_obs_total = []\n",
    "    for t in np.linspace(0., t_total, t_total * 3 + 1):\n",
    "        z_obs = []\n",
    "        # get the final state by either evolving with a circuit or the exact operator\n",
    "        if exact:\n",
    "            spin_operators = SpinOps(h.n_qubits)\n",
    "            fin_state = get_evolve_op(t).dot(init_state)\n",
    "        else:\n",
    "            cir_evolve = UAnsatz(5)\n",
    "            construct_trotter_circuit(cir_evolve, h, tau=t/n_steps, steps=n_steps, order=order, grouping='even_odd')\n",
    "            fin_state = cir_evolve.run_state_vector(init_state)\n",
    "        # measure the observable on each site\n",
    "        for site in range(h.n_qubits):\n",
    "            if exact:\n",
    "                z_obs.append(fin_state.conj().T.dot(spin_operators.sigz_p[site]).dot(fin_state))\n",
    "            else:\n",
    "                z_obs.append(cir_evolve.expecval([[1, 'Z' + str(site)]]).numpy()[0])\n",
    "        z_obs_total.append(z_obs)\n",
    "    return np.array(z_obs_total).real  \n",
    "\n",
    "def plot_comparison(**z_obs_to_plot):\n",
    "    \"\"\"\n",
    "    plot comparison between different evolution results\n",
    "    assume each argument passed into it is returned from get_evolution_z_obs() function for the same t_total\n",
    "    \"\"\"\n",
    "    fig, axes = plt.subplots(1, len(z_obs_to_plot), figsize = [len(z_obs_to_plot) * 3, 5.5])\n",
    "    \n",
    "    ax_idx = 0\n",
    "    for label in z_obs_to_plot.keys():\n",
    "        im = axes[ax_idx].imshow(z_obs_to_plot[label], cmap='coolwarm_r', interpolation='kaiser', origin='lower')\n",
    "        axes[ax_idx].set_title(label, fontsize=15)\n",
    "        ax_idx += 1\n",
    "\n",
    "    for ax in axes:\n",
    "        ax.set_xlabel('site', fontsize=15)\n",
    "        ax.set_yticks(np.arange(0, z_obs_total_exact.shape[0], 3))\n",
    "        ax.set_yticklabels(np.arange(0, z_obs_total_exact.shape[0]/3, 1))\n",
    "        ax.set_xticks(np.arange(z_obs_total_exact.shape[1]))\n",
    "        ax.set_xticklabels(np.arange(z_obs_total_exact.shape[1]))\n",
    "\n",
    "    axes[0].set_ylabel('t', fontsize=15)\n",
    "    cax = fig.add_axes([0.92, 0.125, 0.02, 0.755])\n",
    "    \n",
    "    \n",
    "    fig.colorbar(im, cax)\n",
    "    cax.set_ylabel(r'$\\langle S^z_i (t) \\rangle$', fontsize=15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3735e79a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x396 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# calculate the evolution process with circuits of trotter number 25 and 5, and the exact result\n",
    "z_obs_total_exact = get_evolution_z_obs(h, t_total=3, exact=True)\n",
    "z_obs_total_cir = get_evolution_z_obs(h, order=1, n_steps=25, t_total=3)\n",
    "z_obs_total_cir_short = get_evolution_z_obs(h, order=1, n_steps=5, t_total=3)\n",
    "\n",
    "plot_comparison(\n",
    "    Exact=z_obs_total_exact,\n",
    "    L25_Circuit=z_obs_total_cir,\n",
    "    L5_Circuit=z_obs_total_cir_short)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "707ecfdf",
   "metadata": {},
   "source": [
    "Observed that with 25 trotter blocks, the circuit could very well simulate the spin dynamics for the entire period. In contrast, the shorter circuit with only 5 trotter blocks could only describe the system's behavior correctly up to a certain time until the simulation breaks down.\n",
    "\n",
    "**Exercise：** Could the readers try to observe the evolution of spatial spin correlation function $\\langle S_i^z S_j^{z} \\rangle$？"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af97d494",
   "metadata": {},
   "source": [
    "## Design customized trotter circuit with random permutation\n",
    "\n",
    "### Random permutation\n",
    "\n",
    "Although it seems more physically reasonable to group the commuting terms in the Hamiltonian to achieve better simulation performance, many evidence has shown that using a fixed order Hamiltonian for each trotter block might cause the errors to accumulate. On the other hand, evolving the Hamiltonian according to an random ordering might \"wash-out\" some of the coherent error in the simulation process and replace it with less harmful stochastic noise [8]. Both theoretical analyses on the error upper bound and empirical evidences show that this randomization could effectively reduce the simulation error [9]."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ecc2ea0",
   "metadata": {},
   "source": [
    "### Customize trotter circuit construction\n",
    "\n",
    "By default, the function `construct_trotter_circuit()` constructs a time evolving circuit according to the Suzuki product formula. However, users could choose to customize both the coefficients and permutations by setting `method='custom'` and passing custom arrays to arguments `permutation` and `coefficient`. \n",
    "\n",
    "**Note:** The user should be very cautious when using arguments `coefficient`, `tau` and `steps` altogether. By setting `steps` other than 1 and `tau` other than $t$ (the total evolution time), it is possible to further trotterize the custom coefficient and permutation. For example, when setting `permutation=np.arange(h.n_qubits)` and `coefficient=np.ones(h.n_qubits)`, the effect of `tau` and `steps` is exactly the same as constructing the first-order product formula circuit."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8afa9fe1",
   "metadata": {},
   "source": [
    "Let us further demonstrate the customization function with a concrete example. With the same spin chain Hamiltonian, now we wish to design an evolution strategy similar to the first-order product formula, however the ordering of the Hamiltonian terms within each trotter block is independently random. We could implement this by pass an arraying of shape `(n_steps, h.n_terms)` to the argument `permutation`, and each row of that array is a random permutation $P(N)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f70ab81b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# An example for customize permutation\n",
    "permutation = np.vstack([np.random.permutation(h.n_terms) for i in range(100)])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d189064",
   "metadata": {},
   "source": [
    "Then, we compare the fidelity of such strategy with the first order product formula under different trotter length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "6d6910c9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def compare(n_steps):\n",
    "    \"\"\"\n",
    "    compare the first order product formula and random permutation's fidelity for a fixed evolution time t=2\n",
    "    input n_steps is the number of trotter steps\n",
    "    output is respectively the first order PF and random permutations' fidelity \n",
    "    \"\"\"\n",
    "    t = 2\n",
    "    cir_evolve = UAnsatz(5)\n",
    "    construct_trotter_circuit(cir_evolve, h, tau=t/n_steps, steps=n_steps, order=1)\n",
    "    U_cir = cir_evolve.U.numpy()\n",
    "    fid_suzuki = gate_fidelity(get_evolve_op(t), U_cir)\n",
    "    cir_permute = UAnsatz(5)\n",
    "    permutation = np.vstack([np.random.permutation(h.n_terms) for i in range(n_steps)])\n",
    "    # when coefficient is not specified, a normalized uniform coefficient will be automatically set\n",
    "    construct_trotter_circuit(cir_permute, h, tau=t, steps=1, method='custom', permutation=permutation)\n",
    "    U_cir = cir_permute.U.numpy()\n",
    "    fid_random = gate_fidelity(get_evolve_op(t), U_cir)\n",
    "    return fid_suzuki, fid_random\n",
    "\n",
    "# compare the two fidelity for different trotter steps\n",
    "# as a demo, we only run the experiment once. Interested readers could run multiple times to calculate the error bar\n",
    "n_range = [100, 200, 500, 1000]\n",
    "result = [compare(n) for n in n_range]\n",
    "\n",
    "result = 1 - np.array(result)\n",
    "plt.loglog(n_range, result[:, 0], 'o-', label='1st order PF')\n",
    "plt.loglog(n_range, result[:, 1], 'o-', label='Random')\n",
    "plt.xlabel(r'Trotter number $r$', fontsize=12)\n",
    "plt.ylabel(r'Error: $1 - {\\rm Fid}$', fontsize=12)\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48fc79ff",
   "metadata": {},
   "source": [
    "The 1st order PF refers to the first order product formula circuit with a fixed order. As expected, there is a good improvement in the fidelity for randomized trotter circuit over the first order product formula. \n",
    "\n",
    "**Note:** In [9], the authors noted that the randomization achieved better performance without even utilizing any specific information about the Hamiltonian, and there should be a even more efficient algorithm compared to the simple randomization."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfe2c24e",
   "metadata": {},
   "source": [
    "## Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92832953",
   "metadata": {},
   "source": [
    "Dynamical simulation plays a central role in the research of exotic quantum states. Due to its highly entangled nature, both experimental and theoretical research constitute highly challenging topics. Up until now, people haven't been able to fully understand the physics on some of the two-dimensional or even one-dimensional spin systems. On the other hand, the rapid development of general quantum computers and a series of quantum simulators give researchers new tools to deal with these challenging problems. Take the general quantum computer as an example, it could use digital simulation to simulate almost any quantum system's evolution process under complex conditions (for example a time-dependent Hamiltonian), which is beyond the reach of any classical computer. As the number of qubits and their precisions grow, it seems more like a question of when will the quantum computer surpass its classical counterpart on the tasks of quantum simulation. And among those tasks, it is commonly believed that the simulation of quantum spin systems will be one of the few cases where this breakthrough will first happen. \n",
    "\n",
    "We have presented in this tutorial a hands-on case of simulating dynamical process on a quantum spin model with Paddle Quantum, and further discussed the possibility of designing new time-evolving strategies. Users can now easily design and benchmark their time evolution circuits with  the `construct_trotter_circuit()` function and methods provided in the `Hamiltonian` and `SpinOps` class. We encourage our users to experiment and explore various time evolution strategies on different quantum systems. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff5b39fa",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## References\n",
    "\n",
    "[1] Childs, Andrew M., et al. \"Toward the first quantum simulation with quantum speedup.\" [Proceedings of the National Academy of Sciences 115.38 (2018): 9456-9461](https://www.pnas.org/content/115/38/9456.short).\n",
    "\n",
    "[2] Eckle, Hans-Peter. Models of Quantum Matter: A First Course on Integrability and the Bethe Ansatz. [Oxford University Press, 2019](https://oxford.universitypressscholarship.com/view/10.1093/oso/9780199678839.001.0001/oso-9780199678839).\n",
    "\n",
    "[3] Mikeska, Hans-Jürgen, and Alexei K. Kolezhuk. \"One-dimensional magnetism.\" Quantum magnetism. Springer, Berlin, Heidelberg, 2004. 1-83.\n",
    "\n",
    "[4] Berger, L., S. A. Friedberg, and J. T. Schriempf. \"Magnetic Susceptibility of $\\rm Cu(NO_3)_2·2.5 H_2O$ at Low Temperature.\" [Physical Review 132.3 (1963): 1057](https://journals.aps.org/pr/abstract/10.1103/PhysRev.132.1057).\n",
    "\n",
    "[5] Broholm, C., et al. \"Quantum spin liquids.\" [Science 367.6475 (2020)](https://science.sciencemag.org/content/367/6475/eaay0668).\n",
    "\n",
    "[6] Abanin, Dmitry A., et al. \"Colloquium: Many-body localization, thermalization, and entanglement.\" [Reviews of Modern Physics 91.2 (2019): 021001](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.91.021001).\n",
    "\n",
    "[7] Medenjak, Marko, Berislav Buča, and Dieter Jaksch. \"Isolated Heisenberg magnet as a quantum time crystal.\" [Physical Review B 102.4 (2020): 041117](https://journals.aps.org/prb/abstract/10.1103/PhysRevB.102.041117).\n",
    "\n",
    "[8] Wallman, Joel J., and Joseph Emerson. \"Noise tailoring for scalable quantum computation via randomized compiling.\" [Physical Review A 94.5 (2016): 052325](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.94.052325).\n",
    "\n",
    "[9] Childs, Andrew M., Aaron Ostrander, and Yuan Su. \"Faster quantum simulation by randomization.\" [Quantum 3 (2019): 182](https://quantum-journal.org/papers/q-2019-09-02-182/)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}